@rsbuild/core 0.7.8 → 0.7.9

package/dist/index.cjs

@@ -118,7 +118,7 @@ var init_format = __esm({
 });
 
 // src/constants.ts
-var import_node_path, ROOT_DIST_DIR, HTML_DIST_DIR, SERVER_DIST_DIR, SERVICE_WORKER_DIST_DIR, JS_DIST_DIR, CSS_DIST_DIR, SVG_DIST_DIR, FONT_DIST_DIR, WASM_DIST_DIR, IMAGE_DIST_DIR, MEDIA_DIST_DIR, LOADER_PATH, STATIC_PATH, COMPILED_PATH, TS_CONFIG_FILE, DEFAULT_PORT, DEFAULT_DATA_URL_SIZE, DEFAULT_MOUNT_ID, DEFAULT_DEV_HOST, HTML_REGEX, CSS_REGEX, PLUGIN_SWC_NAME, PLUGIN_CSS_NAME, FONT_EXTENSIONS, IMAGE_EXTENSIONS, VIDEO_EXTENSIONS, AUDIO_EXTENSIONS;
+var import_node_path, ROOT_DIST_DIR, HTML_DIST_DIR, SERVER_DIST_DIR, SERVICE_WORKER_DIST_DIR, JS_DIST_DIR, CSS_DIST_DIR, SVG_DIST_DIR, FONT_DIST_DIR, WASM_DIST_DIR, IMAGE_DIST_DIR, MEDIA_DIST_DIR, LOADER_PATH, STATIC_PATH, COMPILED_PATH, TS_CONFIG_FILE, DEFAULT_PORT, DEFAULT_DATA_URL_SIZE, DEFAULT_MOUNT_ID, DEFAULT_DEV_HOST, HTML_REGEX, CSS_REGEX, PLUGIN_SWC_NAME, PLUGIN_CSS_NAME, FONT_EXTENSIONS, IMAGE_EXTENSIONS, VIDEO_EXTENSIONS, AUDIO_EXTENSIONS, TARGET_ID_MAP;
 var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
@@ -165,6 +165,48 @@ var init_constants = __esm({
     ];
     VIDEO_EXTENSIONS = ["mp4", "webm", "ogg", "mov"];
     AUDIO_EXTENSIONS = ["mp3", "wav", "flac", "aac", "m4a", "opus"];
+    TARGET_ID_MAP = {
+      web: "Client",
+      node: "Server",
+      "web-worker": "Web Worker",
+      "service-worker": "Service Worker"
+    };
+  }
+});
+
+// src/logger.ts
+function getTime() {
+  const now = /* @__PURE__ */ new Date();
+  const hours = String(now.getHours()).padStart(2, "0");
+  const minutes = String(now.getMinutes()).padStart(2, "0");
+  const seconds = String(now.getSeconds()).padStart(2, "0");
+  return `${hours}:${minutes}:${seconds}`;
+}
+var import_shared, import_rslog, isDebug;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    import_shared = require("@rsbuild/shared");
+    import_rslog = require("../compiled/rslog/index.js");
+    isDebug = () => {
+      if (!process.env.DEBUG) {
+        return false;
+      }
+      const values = process.env.DEBUG.toLocaleLowerCase().split(",");
+      return ["rsbuild", "builder", "*"].some((key) => values.includes(key));
+    };
+    if (isDebug()) {
+      import_rslog.logger.level = "verbose";
+    }
+    import_rslog.logger.override({
+      debug: (message, ...args) => {
+        if (import_rslog.logger.level !== "verbose") {
+          return;
+        }
+        const time = import_shared.color.gray(`${getTime()}`);
+        console.log(`  ${import_shared.color.magenta("rsbuild")} ${time} ${message}`, ...args);
+      }
+    });
   }
 });
 
@@ -174,14 +216,14 @@ function formatErrorMessage(errors) {
   const text = `${messages.join("\n\n")}
 `;
   const isTerserError = text.includes("from Terser");
-  const title = import_shared.color.bold(
-    import_shared.color.red(isTerserError ? "Minify error: " : "Compile error: ")
+  const title = import_shared2.color.bold(
+    import_shared2.color.red(isTerserError ? "Minify error: " : "Compile error: ")
   );
   if (!errors.length) {
     return `${title}
-${import_shared.color.yellow(`For more details, please setting 'stats.errors: true' `)}`;
+${import_shared2.color.yellow(`For more details, please setting 'stats.errors: true' `)}`;
   }
-  const tip = import_shared.color.yellow(
+  const tip = import_shared2.color.yellow(
     isTerserError ? "Failed to minify with terser, check for syntax errors." : "Failed to compile, check the errors for troubleshooting."
   );
   return `${title}
@@ -189,7 +231,7 @@ ${tip}
 ${text}`;
 }
 function getStatsOptions(compiler) {
-  if ((0, import_shared.isMultiCompiler)(compiler)) {
+  if (isMultiCompiler(compiler)) {
     return {
       children: compiler.compilers.map(
         (compiler2) => compiler2.options ? compiler2.options.stats : void 0
@@ -212,7 +254,7 @@ function formatStats(stats, options = {}) {
       warnings: getAllStatsWarnings(statsData)
     },
     // display verbose messages in prod build or debug mode
-    (0, import_shared.isProd)() || (0, import_shared.isDebug)()
+    (0, import_shared2.isProd)() || import_rslog.logger.level === "verbose"
   );
   if (stats.hasErrors()) {
     return {
@@ -221,7 +263,7 @@ function formatStats(stats, options = {}) {
     };
   }
   if (warnings.length) {
-    const title = import_shared.color.bold(import_shared.color.yellow("Compile Warning: \n"));
+    const title = import_shared2.color.bold(import_shared2.color.yellow("Compile Warning: \n"));
     return {
       message: `${title}${warnings.join("\n\n")}
 `,
@@ -231,21 +273,86 @@ function formatStats(stats, options = {}) {
   return {};
 }
 function isEmptyDir(path13) {
-  const files = import_shared2.fse.readdirSync(path13);
+  const files = import_shared3.fse.readdirSync(path13);
   return files.length === 0 || files.length === 1 && files[0] === ".git";
 }
 async function isFileExists(file) {
-  return import_shared2.fse.promises.access(file, import_shared2.fse.constants.F_OK).then(() => true).catch(() => false);
+  return import_shared3.fse.promises.access(file, import_shared3.fse.constants.F_OK).then(() => true).catch(() => false);
+}
+function getFilename(config, type, isProd7) {
+  const { filename, filenameHash } = config.output;
+  const getHash = () => {
+    if (typeof filenameHash === "string") {
+      return filenameHash ? `.[${filenameHash}]` : "";
+    }
+    return filenameHash ? ".[contenthash:8]" : "";
+  };
+  const hash = getHash();
+  switch (type) {
+    case "js":
+      return filename.js ?? `[name]${isProd7 ? hash : ""}.js`;
+    case "css":
+      return filename.css ?? `[name]${isProd7 ? hash : ""}.css`;
+    case "svg":
+      return filename.svg ?? `[name]${hash}.svg`;
+    case "font":
+      return filename.font ?? `[name]${hash}[ext]`;
+    case "image":
+      return filename.image ?? `[name]${hash}[ext]`;
+    case "media":
+      return filename.media ?? `[name]${hash}[ext]`;
+    default:
+      throw new Error(`unknown key ${type} in "output.filename"`);
+  }
+}
+function partition(array, predicate) {
+  const truthy = [];
+  const falsy = [];
+  for (const value of array) {
+    if (predicate(value)) {
+      truthy.push(value);
+    } else {
+      falsy.push(value);
+    }
+  }
+  return [truthy, falsy];
 }
-var import_node_path2, import_shared, import_shared2, rspackMinVersion, compareSemver, isSatisfyRspackVersion, getCompiledPath, hintNodePolyfill, getAllStatsErrors, getAllStatsWarnings, formatPublicPath, getPublicPathFromChain, ensureAbsolutePath, isFileSync, findExists, urlJoin, canParse, ensureAssetPrefix;
+function debounce(func, wait) {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      func(...args);
+    }, wait);
+  };
+}
+function isWebTarget(target) {
+  const targets = (0, import_shared2.castArray)(target);
+  return targets.includes("web") || target.includes("web-worker");
+}
+function pick(obj, keys) {
+  return keys.reduce(
+    (ret, key) => {
+      if (obj[key] !== void 0) {
+        ret[key] = obj[key];
+      }
+      return ret;
+    },
+    {}
+  );
+}
+var import_node_path2, import_shared2, import_shared3, rspackMinVersion, compareSemver, isSatisfyRspackVersion, getCompiledPath, hintNodePolyfill, getAllStatsErrors, getAllStatsWarnings, removeLeadingSlash, removeTailingSlash, addTrailingSlash, formatPublicPath, getPublicPathFromChain, ensureAbsolutePath, isFileSync, findExists, urlJoin, canParse, ensureAssetPrefix, applyToCompiler, upperFirst, isURL, createVirtualModule, isRegExp, isMultiCompiler, onCompileDone;
 var init_helpers = __esm({
   "src/helpers.ts"() {
     "use strict";
     import_node_path2 = __toESM(require("path"));
-    import_shared = require("@rsbuild/shared");
     import_shared2 = require("@rsbuild/shared");
+    import_shared3 = require("@rsbuild/shared");
     init_format();
     init_constants();
+    init_logger();
     rspackMinVersion = "0.6.2";
     compareSemver = (version1, version2) => {
       const parts1 = version1.split(".").map(Number);
@@ -330,7 +437,7 @@ var init_helpers = __esm({
         ];
         return `${message}
 
-${import_shared.color.yellow(tips.join("\n"))}`;
+${import_shared2.color.yellow(tips.join("\n"))}`;
       }
       return message;
     };
@@ -352,23 +459,26 @@ ${import_shared.color.yellow(tips.join("\n"))}`;
       }
       return statsData.warnings;
     };
+    removeLeadingSlash = (s) => s.replace(/^\/+/, "");
+    removeTailingSlash = (s) => s.replace(/\/+$/, "");
+    addTrailingSlash = (s) => s.endsWith("/") ? s : `${s}/`;
     formatPublicPath = (publicPath, withSlash = true) => {
       if (publicPath === "auto") {
         return publicPath;
       }
-      return withSlash ? (0, import_shared.addTrailingSlash)(publicPath) : (0, import_shared.removeTailingSlash)(publicPath);
+      return withSlash ? addTrailingSlash(publicPath) : removeTailingSlash(publicPath);
     };
     getPublicPathFromChain = (chain, withSlash = true) => {
       const publicPath = chain.output.get("publicPath");
       if (typeof publicPath === "string") {
         return formatPublicPath(publicPath, withSlash);
       }
-      return formatPublicPath(import_shared.DEFAULT_ASSET_PREFIX, withSlash);
+      return formatPublicPath(import_shared2.DEFAULT_ASSET_PREFIX, withSlash);
     };
     ensureAbsolutePath = (base, filePath) => import_node_path2.default.isAbsolute(filePath) ? filePath : import_node_path2.default.resolve(base, filePath);
     isFileSync = (filePath) => {
       try {
-        return import_shared2.fse.statSync(filePath, { throwIfNoEntry: false })?.isFile();
+        return import_shared3.fse.statSync(filePath, { throwIfNoEntry: false })?.isFile();
       } catch (_) {
         return false;
       }
@@ -409,15 +519,59 @@ ${import_shared.color.yellow(tips.join("\n"))}`;
       }
       return import_node_path2.posix.join(assetPrefix, url2);
     };
+    applyToCompiler = (compiler, apply) => {
+      if (isMultiCompiler(compiler)) {
+        compiler.compilers.forEach(apply);
+      } else {
+        apply(compiler);
+      }
+    };
+    upperFirst = (str) => str ? str.charAt(0).toUpperCase() + str.slice(1) : "";
+    isURL = (str) => str.startsWith("http") || str.startsWith("//:");
+    createVirtualModule = (content) => `data:text/javascript,${content}`;
+    isRegExp = (obj) => Object.prototype.toString.call(obj) === "[object RegExp]";
+    isMultiCompiler = (compiler) => {
+      return compiler.constructor.name === "MultiCompiler";
+    };
+    onCompileDone = (compiler, onDone, MultiStatsCtor) => {
+      if (isMultiCompiler(compiler)) {
+        const { compilers } = compiler;
+        const compilerStats = [];
+        let doneCompilers = 0;
+        for (let index = 0; index < compilers.length; index++) {
+          const compiler2 = compilers[index];
+          const compilerIndex = index;
+          let compilerDone = false;
+          compiler2.hooks.done.tapPromise("rsbuild:done", async (stats) => {
+            if (!compilerDone) {
+              compilerDone = true;
+              doneCompilers++;
+            }
+            compilerStats[compilerIndex] = stats;
+            if (doneCompilers === compilers.length) {
+              await onDone(new MultiStatsCtor(compilerStats));
+            }
+          });
+          compiler2.hooks.invalid.tap("rsbuild:done", () => {
+            if (compilerDone) {
+              compilerDone = false;
+              doneCompilers--;
+            }
+          });
+        }
+      } else {
+        compiler.hooks.done.tapPromise("rsbuild:done", onDone);
+      }
+    };
   }
 });
 
 // src/mergeConfig.ts
-var import_shared3, OVERRIDE_PATH, isOverridePath, merge, mergeRsbuildConfig;
+var import_shared4, OVERRIDE_PATH, isOverridePath, merge, mergeRsbuildConfig;
 var init_mergeConfig = __esm({
   "src/mergeConfig.ts"() {
     "use strict";
-    import_shared3 = require("@rsbuild/shared");
+    import_shared4 = require("@rsbuild/shared");
     OVERRIDE_PATH = [
       "performance.removeConsole",
       "output.inlineScripts",
@@ -443,12 +597,12 @@ var init_mergeConfig = __esm({
       }
       const pair = [x, y];
       if (pair.some(Array.isArray)) {
-        return [...(0, import_shared3.castArray)(x), ...(0, import_shared3.castArray)(y)];
+        return [...(0, import_shared4.castArray)(x), ...(0, import_shared4.castArray)(y)];
       }
-      if (pair.some(import_shared3.isFunction)) {
+      if (pair.some(import_shared4.isFunction)) {
         return pair;
       }
-      if (!(0, import_shared3.isPlainObject)(x) || !(0, import_shared3.isPlainObject)(y)) {
+      if (!(0, import_shared4.isPlainObject)(x) || !(0, import_shared4.isPlainObject)(y)) {
         return y;
       }
       const merged = {};
@@ -475,13 +629,14 @@ var init_mergeConfig = __esm({
 });
 
 // src/server/restart.ts
-var import_node_path3, import_shared4, cleaners, onBeforeRestartServer, clearConsole, restartDevServer;
+var import_node_path3, import_shared5, cleaners, onBeforeRestartServer, clearConsole, restartDevServer;
 var init_restart = __esm({
   "src/server/restart.ts"() {
     "use strict";
     import_node_path3 = __toESM(require("path"));
-    import_shared4 = require("@rsbuild/shared");
+    import_shared5 = require("@rsbuild/shared");
     init_init();
+    init_logger();
     cleaners = [];
     onBeforeRestartServer = (cleaner) => {
       cleaners.push(cleaner);
@@ -494,7 +649,7 @@ var init_restart = __esm({
     restartDevServer = async ({ filePath }) => {
       clearConsole();
       const filename = import_node_path3.default.basename(filePath);
-      import_shared4.logger.info(`Restart because ${import_shared4.color.yellow(filename)} is changed.
+      import_rslog.logger.info(`Restart because ${import_shared5.color.yellow(filename)} is changed.
 `);
       for (const cleaner of cleaners) {
         await cleaner();
@@ -543,7 +698,7 @@ async function watchFiles(files) {
     // If watching fails due to read permissions, the errors will be suppressed silently.
     ignorePermissionErrors: true
   });
-  const callback = (0, import_shared5.debounce)(
+  const callback = debounce(
     async (filePath) => {
       watcher.close();
       await restartDevServer({ filePath });
@@ -583,22 +738,22 @@ async function loadConfig({
     if (typeof configExport === "function") {
       const command = process.argv[2];
       const params = {
-        env: (0, import_shared5.getNodeEnv)(),
+        env: (0, import_shared6.getNodeEnv)(),
         command,
-        envMode: envMode || (0, import_shared5.getNodeEnv)()
+        envMode: envMode || (0, import_shared6.getNodeEnv)()
       };
       const result = await configExport(params);
       if (result === void 0) {
-        throw new Error("Rsbuild config function must return a config object.");
+        throw new Error("The config function must return a config object.");
       }
       return {
         content: applyMetaInfo(result),
         filePath: configFilePath
       };
     }
-    if (!(0, import_shared5.isObject)(configExport)) {
+    if (!(0, import_shared6.isObject)(configExport)) {
       throw new Error(
-        `Rsbuild config must be an object or a function that returns an object, get ${import_shared5.color.yellow(
+        `The config must be an object or a function that returns an object, get ${import_shared6.color.yellow(
           configExport
         )}`
       );
@@ -608,7 +763,7 @@ async function loadConfig({
       filePath: configFilePath
     };
   } catch (err) {
-    import_shared5.logger.error(`Failed to load file: ${import_shared5.color.dim(configFilePath)}`);
+    import_rslog.logger.error(`Failed to load file: ${import_shared6.color.dim(configFilePath)}`);
     throw err;
   }
 }
@@ -630,27 +785,27 @@ async function outputInspectConfigFiles({
       const suffix = rsbuildConfig.output.targets[index];
       const outputFile = `${configType}.config.${suffix}.mjs`;
       let outputFilePath = (0, import_node_path4.join)(outputPath, outputFile);
-      if (import_shared5.fse.existsSync(outputFilePath)) {
+      if (import_shared6.fse.existsSync(outputFilePath)) {
         outputFilePath = outputFilePath.replace(/\.mjs$/, `.${Date.now()}.mjs`);
       }
       return {
         path: outputFilePath,
-        label: `${(0, import_shared5.upperFirst)(configType)} Config (${suffix})`,
+        label: `${upperFirst(configType)} Config (${suffix})`,
         content
       };
     })
   ];
   await Promise.all(
     files.map(
-      (item) => import_shared5.fse.outputFile(item.path, `export default ${item.content}`)
+      (item) => import_shared6.fse.outputFile(item.path, `export default ${item.content}`)
     )
   );
   const fileInfos = files.map(
-    (item) => `  - ${import_shared5.color.bold(import_shared5.color.yellow(item.label))}: ${import_shared5.color.underline(
+    (item) => `  - ${import_shared6.color.bold(import_shared6.color.yellow(item.label))}: ${import_shared6.color.underline(
       item.path
     )}`
   ).join("\n");
-  import_shared5.logger.success(
+  import_rslog.logger.success(
     `Inspect config succeed, open following files to view the content: 
 
 ${fileInfos}
@@ -658,24 +813,25 @@ ${fileInfos}
   );
 }
 async function stringifyConfig(config, verbose) {
-  const stringify = import_shared5.RspackChain.toString;
+  const stringify = import_shared6.RspackChain.toString;
   return stringify(config, { verbose });
 }
-var import_node_fs, import_node_path4, import_shared5, getDefaultDevConfig, getDefaultServerConfig, getDefaultSourceConfig, getDefaultHtmlConfig, getDefaultSecurityConfig, getDefaultToolsConfig, getDefaultPerformanceConfig, getDefaultOutputConfig, createDefaultConfig, withDefaultConfig, normalizeConfig, resolveConfigPath, normalizePublicDirs;
+var import_node_fs, import_node_path4, import_shared6, getDefaultDevConfig, getDefaultServerConfig, getDefaultSourceConfig, getDefaultHtmlConfig, getDefaultSecurityConfig, getDefaultToolsConfig, getDefaultPerformanceConfig, getDefaultOutputConfig, createDefaultConfig, withDefaultConfig, normalizeConfig, resolveConfigPath, normalizePublicDirs;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     import_node_fs = __toESM(require("fs"));
     import_node_path4 = require("path");
-    import_shared5 = require("@rsbuild/shared");
+    import_shared6 = require("@rsbuild/shared");
     init_constants();
     init_helpers();
+    init_logger();
     init_mergeConfig();
     init_restart();
     getDefaultDevConfig = () => ({
       hmr: true,
       liveReload: true,
-      assetPrefix: import_shared5.DEFAULT_ASSET_PREFIX,
+      assetPrefix: import_shared6.DEFAULT_ASSET_PREFIX,
       startUrl: false,
       client: {
         overlay: true
@@ -750,7 +906,7 @@ var init_config = __esm({
         server: SERVER_DIST_DIR,
         worker: SERVICE_WORKER_DIST_DIR
       },
-      assetPrefix: import_shared5.DEFAULT_ASSET_PREFIX,
+      assetPrefix: import_shared6.DEFAULT_ASSET_PREFIX,
       filename: {},
       charset: "ascii",
       polyfill: "usage",
@@ -810,7 +966,7 @@ var init_config = __esm({
         if (import_node_fs.default.existsSync(customConfigPath)) {
           return customConfigPath;
         }
-        import_shared5.logger.warn(`Cannot find config file: ${import_shared5.color.dim(customConfigPath)}
+        import_rslog.logger.warn(`Cannot find config file: ${import_shared6.color.dim(customConfigPath)}
 `);
       }
       const CONFIG_FILES = [
@@ -860,7 +1016,7 @@ var init_config = __esm({
 // src/loadEnv.ts
 function loadEnv({
   cwd = process.cwd(),
-  mode = (0, import_shared6.getNodeEnv)(),
+  mode = (0, import_shared7.getNodeEnv)(),
   prefixes = ["PUBLIC_"]
 } = {}) {
   if (mode === "local") {
@@ -910,13 +1066,13 @@ function loadEnv({
     publicVars
   };
 }
-var import_node_fs2, import_node_path5, import_shared6, import_dotenv, import_dotenv_expand;
+var import_node_fs2, import_node_path5, import_shared7, import_dotenv, import_dotenv_expand;
 var init_loadEnv = __esm({
   "src/loadEnv.ts"() {
     "use strict";
     import_node_fs2 = __toESM(require("fs"));
     import_node_path5 = require("path");
-    import_shared6 = require("@rsbuild/shared");
+    import_shared7 = require("@rsbuild/shared");
     import_dotenv = require("../compiled/dotenv/index.js");
     import_dotenv_expand = require("../compiled/dotenv-expand/index.js");
     init_helpers();
@@ -929,7 +1085,7 @@ function createAsyncHook() {
   const postGroup = [];
   const defaultGroup = [];
   const tap = (cb) => {
-    if ((0, import_shared7.isFunction)(cb)) {
+    if ((0, import_shared8.isFunction)(cb)) {
       defaultGroup.push(cb);
     } else if (cb.order === "pre") {
       preGroup.push(cb.handler);
@@ -976,11 +1132,11 @@ function initHooks() {
     modifyRsbuildConfig: createAsyncHook()
   };
 }
-var import_shared7;
+var import_shared8;
 var init_initHooks = __esm({
   "src/initHooks.ts"() {
     "use strict";
-    import_shared7 = require("@rsbuild/shared");
+    import_shared8 = require("@rsbuild/shared");
   }
 });
 
@@ -994,17 +1150,18 @@ function getEntryObject(config, target) {
   if (!config.source?.entry) {
     return {};
   }
-  return (0, import_shared8.reduceConfigsMergeContext)({
+  return (0, import_shared9.reduceConfigsMergeContext)({
     initial: {},
     config: config.source?.entry,
     ctx: { target }
   });
 }
-var import_shared8, pluginEntry;
+var import_shared9, pluginEntry;
 var init_entry = __esm({
   "src/plugins/entry.ts"() {
     "use strict";
-    import_shared8 = require("@rsbuild/shared");
+    import_shared9 = require("@rsbuild/shared");
+    init_helpers();
     pluginEntry = () => ({
       name: "rsbuild:entry",
       setup(api) {
@@ -1021,18 +1178,18 @@ var init_entry = __esm({
               };
               preEntry.forEach(addEntry);
               if (injectCoreJsEntry) {
-                addEntry((0, import_shared8.createVirtualModule)('import "core-js";'));
+                addEntry(createVirtualModule('import "core-js";'));
               }
-              (0, import_shared8.castArray)(entry[entryName]).forEach(addEntry);
+              (0, import_shared9.castArray)(entry[entryName]).forEach(addEntry);
             }
           }
         );
         api.onBeforeCreateCompiler(({ bundlerConfigs }) => {
           if (bundlerConfigs.every((config) => !config.entry)) {
             throw new Error(
-              `Could not find any entry module, please make sure that ${import_shared8.color.cyan(
+              `Could not find any entry module, please make sure that ${import_shared9.color.cyan(
                 "src/index.(ts|js|tsx|jsx|mjs|cjs)"
-              )} exists, or customize entry through the ${import_shared8.color.cyan(
+              )} exists, or customize entry through the ${import_shared9.color.cyan(
                 "source.entry"
               )} configuration.`
             );
@@ -1048,7 +1205,7 @@ function getAbsolutePath(root, filepath) {
   return (0, import_node_path6.isAbsolute)(filepath) ? filepath : (0, import_node_path6.join)(root, filepath);
 }
 function getAbsoluteDistPath(cwd, config) {
-  const dirRoot = (0, import_shared9.getDistPath)(config, "root");
+  const dirRoot = config.output?.distPath?.root ?? ROOT_DIST_DIR;
   return getAbsolutePath(cwd, dirRoot);
 }
 async function createContextByConfig(options, bundlerType, config = {}) {
@@ -1060,7 +1217,7 @@ async function createContextByConfig(options, bundlerType, config = {}) {
   return {
     entry: getEntryObject(config, "web"),
     targets: config.output?.targets || [],
-    version: "0.7.8",
+    version: "0.7.9",
     rootPath,
     distPath,
     cachePath,
@@ -1102,7 +1259,7 @@ function createPublicContext(context) {
       return void 0;
     },
     set(_, prop) {
-      import_shared9.logger.error(
+      import_rslog.logger.error(
         `Context is readonly, you can not assign to the "context.${prop}" prop.`
       );
       return true;
@@ -1123,23 +1280,23 @@ async function createContext(options, userRsbuildConfig, bundlerType) {
     originalConfig: userRsbuildConfig
   };
 }
-var import_node_path6, import_shared9;
+var import_node_path6;
 var init_createContext = __esm({
   "src/createContext.ts"() {
     "use strict";
     import_node_path6 = require("path");
-    import_shared9 = require("@rsbuild/shared");
     init_config();
+    init_constants();
     init_initHooks();
+    init_logger();
     init_entry();
   }
 });
 
 // src/initPlugins.ts
 function getHTMLPathByEntry(entryName, config) {
-  const htmlPath = (0, import_shared10.getDistPath)(config, "html");
   const filename = config.html.outputStructure === "flat" ? `${entryName}.html` : `${entryName}/index.html`;
-  return (0, import_shared10.removeLeadingSlash)(`${htmlPath}/${filename}`);
+  return removeLeadingSlash(`${config.output.distPath.html}/${filename}`);
 }
 function applyTransformPlugin(chain, transformer) {
   const name = "RsbuildTransformPlugin";
@@ -1256,14 +1413,14 @@ function getPluginAPI({
     modifyRsbuildConfig: hooks.modifyRsbuildConfig.tap
   };
 }
-var import_node_path7, import_shared10;
+var import_node_path7;
 var init_initPlugins = __esm({
   "src/initPlugins.ts"() {
     "use strict";
     import_node_path7 = require("path");
-    import_shared10 = require("@rsbuild/shared");
     init_constants();
     init_createContext();
+    init_helpers();
   }
 });
 
@@ -1304,18 +1461,18 @@ function validatePlugin(plugin) {
       `Expect Rsbuild plugin instance to be an object, but got ${type}.`
     );
   }
-  if ((0, import_shared11.isFunction)(plugin.setup)) {
+  if ((0, import_shared10.isFunction)(plugin.setup)) {
     return;
   }
-  if ((0, import_shared11.isFunction)(plugin.apply)) {
+  if ((0, import_shared10.isFunction)(plugin.apply)) {
     const { name = "SomeWebpackPlugin" } = plugin.constructor || {};
     const messages = [
-      `${import_shared11.color.yellow(
+      `${import_shared10.color.yellow(
         name
-      )} looks like a Webpack or Rspack plugin, please use ${import_shared11.color.yellow(
+      )} looks like a Webpack or Rspack plugin, please use ${import_shared10.color.yellow(
         "`tools.rspack`"
       )} to register it:`,
-      import_shared11.color.green(`
+      import_shared10.color.green(`
   // rsbuild.config.ts
   export default {
     tools: {
@@ -1342,13 +1499,13 @@ function createPluginManager() {
       }
       validatePlugin(newPlugin);
       if (plugins.find((item) => item.name === newPlugin.name)) {
-        import_shared11.logger.warn(
+        import_rslog.logger.warn(
           `Rsbuild plugin "${newPlugin.name}" registered multiple times.`
         );
       } else if (before) {
         const index = plugins.findIndex((item) => item.name === before);
         if (index === -1) {
-          import_shared11.logger.warn(`Plugin "${before}" does not exist.`);
+          import_rslog.logger.warn(`Plugin "${before}" does not exist.`);
           plugins.push(newPlugin);
         } else {
           plugins.splice(index, 0, newPlugin);
@@ -1373,7 +1530,7 @@ async function initPlugins({
   pluginAPI,
   pluginManager
 }) {
-  (0, import_shared11.debug)("init plugins");
+  import_rslog.logger.debug("init plugins");
   const plugins = pluginDagSort(pluginManager.getPlugins());
   const removedPlugins = plugins.reduce((ret, plugin) => {
     if (plugin.remove) {
@@ -1387,13 +1544,14 @@ async function initPlugins({
     }
     await plugin.setup(pluginAPI);
   }
-  (0, import_shared11.debug)("init plugins done");
+  import_rslog.logger.debug("init plugins done");
 }
-var import_shared11, pluginDagSort;
+var import_shared10, pluginDagSort;
 var init_pluginManager = __esm({
   "src/pluginManager.ts"() {
     "use strict";
-    import_shared11 = require("@rsbuild/shared");
+    import_shared10 = require("@rsbuild/shared");
+    init_logger();
     pluginDagSort = (plugins) => {
       let allLines = [];
       function getPlugin(name) {
@@ -1464,9 +1622,9 @@ async function inspectConfig({
   inspectOptions = {}
 }) {
   if (inspectOptions.env) {
-    (0, import_shared12.setNodeEnv)(inspectOptions.env);
-  } else if (!(0, import_shared12.getNodeEnv)()) {
-    (0, import_shared12.setNodeEnv)("development");
+    (0, import_shared11.setNodeEnv)(inspectOptions.env);
+  } else if (!(0, import_shared11.getNodeEnv)()) {
+    (0, import_shared11.setNodeEnv)("development");
   }
   const rspackConfigs = bundlerConfigs || (await initConfigs({
     context,
@@ -1511,20 +1669,81 @@ async function inspectConfig({
     }
   };
 }
-var import_node_path8, import_shared12;
+var import_node_path8, import_shared11;
 var init_inspectConfig = __esm({
   "src/provider/inspectConfig.ts"() {
     "use strict";
     import_node_path8 = require("path");
-    import_shared12 = require("@rsbuild/shared");
+    import_shared11 = require("@rsbuild/shared");
     init_config();
     init_initConfigs();
   }
 });
 
+// src/configChain.ts
+async function getBundlerChain() {
+  const bundlerChain = new import_shared12.RspackChain();
+  return bundlerChain;
+}
+async function modifyBundlerChain(context, utils) {
+  import_rslog.logger.debug("modify bundler chain");
+  const bundlerChain = await getBundlerChain();
+  const [modifiedBundlerChain] = await context.hooks.modifyBundlerChain.call(
+    bundlerChain,
+    utils
+  );
+  if (context.config.tools?.bundlerChain) {
+    for (const item of (0, import_shared12.castArray)(context.config.tools.bundlerChain)) {
+      await item(modifiedBundlerChain, utils);
+    }
+  }
+  import_rslog.logger.debug("modify bundler chain done");
+  return modifiedBundlerChain;
+}
+function chainToConfig(chain) {
+  const config = chain.toConfig();
+  const { entry } = config;
+  if (!(0, import_shared12.isPlainObject)(entry)) {
+    return config;
+  }
+  const formattedEntry = {};
+  for (const [entryName, entryValue] of Object.entries(entry)) {
+    const entryImport = [];
+    let entryDescription = null;
+    for (const item of (0, import_shared12.castArray)(entryValue)) {
+      if (typeof item === "string") {
+        entryImport.push(item);
+        continue;
+      }
+      if (item.import) {
+        entryImport.push(...(0, import_shared12.castArray)(item.import));
+      }
+      if (entryDescription) {
+        Object.assign(entryDescription, item);
+      } else {
+        entryDescription = item;
+      }
+    }
+    formattedEntry[entryName] = entryDescription ? {
+      ...entryDescription,
+      import: entryImport
+    } : entryImport;
+  }
+  config.entry = formattedEntry;
+  return config;
+}
+var import_shared12;
+var init_configChain = __esm({
+  "src/configChain.ts"() {
+    "use strict";
+    import_shared12 = require("@rsbuild/shared");
+    init_logger();
+  }
+});
+
 // src/provider/rspackConfig.ts
 async function modifyRspackConfig(context, rspackConfig, utils) {
-  (0, import_shared13.debug)("modify Rspack config");
+  import_rslog.logger.debug("modify Rspack config");
   let [modifiedConfig] = await context.hooks.modifyRspackConfig.call(
     rspackConfig,
     utils
@@ -1537,7 +1756,7 @@ async function modifyRspackConfig(context, rspackConfig, utils) {
       mergeFn: utils.mergeConfig
     });
   }
-  (0, import_shared13.debug)("modify Rspack config done");
+  import_rslog.logger.debug("modify Rspack config done");
   return modifiedConfig;
 }
 async function getConfigUtils(config, chainUtils) {
@@ -1605,7 +1824,7 @@ async function generateRspackConfig({
     ProvidePlugin,
     HotModuleReplacementPlugin
   } = import_core2.rspack;
-  const chain = await (0, import_shared13.modifyBundlerChain)(context, {
+  const chain = await modifyBundlerChain(context, {
     ...chainUtils,
     bundler: {
       BannerPlugin,
@@ -1615,7 +1834,7 @@ async function generateRspackConfig({
       HotModuleReplacementPlugin
     }
   });
-  let rspackConfig = (0, import_shared13.chainToConfig)(chain);
+  let rspackConfig = chainToConfig(chain);
   rspackConfig = await modifyRspackConfig(
     context,
     rspackConfig,
@@ -1629,19 +1848,21 @@ var init_rspackConfig = __esm({
     "use strict";
     import_shared13 = require("@rsbuild/shared");
     import_core2 = require("@rspack/core");
+    init_configChain();
+    init_logger();
     init_pluginHelper();
   }
 });
 
 // src/provider/initConfigs.ts
 async function modifyRsbuildConfig(context) {
-  (0, import_shared14.debug)("modify Rsbuild config");
+  import_rslog.logger.debug("modify Rsbuild config");
   const [modified] = await context.hooks.modifyRsbuildConfig.call(
     context.config,
     { mergeRsbuildConfig }
   );
   context.config = modified;
-  (0, import_shared14.debug)("modify Rsbuild config done");
+  import_rslog.logger.debug("modify Rsbuild config done");
 }
 async function initRsbuildConfig({
   context,
@@ -1669,7 +1890,7 @@ async function initConfigs({
   const rspackConfigs = await Promise.all(
     targets.map((target) => generateRspackConfig({ target, context }))
   );
-  if ((0, import_shared14.isDebug)()) {
+  if (isDebug()) {
     const inspect = () => {
       const inspectOptions = {
         verbose: true,
@@ -1690,13 +1911,12 @@ async function initConfigs({
     rspackConfigs
   };
 }
-var import_shared14;
 var init_initConfigs = __esm({
   "src/provider/initConfigs.ts"() {
     "use strict";
-    import_shared14 = require("@rsbuild/shared");
     init_config();
     init_createContext();
+    init_logger();
     init_mergeConfig();
     init_pluginManager();
     init_inspectConfig();
@@ -1708,6 +1928,8 @@ var init_initConfigs = __esm({
 var devMiddleware_exports = {};
 __export(devMiddleware_exports, {
   getDevMiddleware: () => getDevMiddleware,
+  isClientCompiler: () => isClientCompiler,
+  isNodeCompiler: () => isNodeCompiler,
   setupServerHooks: () => setupServerHooks
 });
 function applyHMREntry({
@@ -1716,7 +1938,7 @@ function applyHMREntry({
   clientConfig = {},
   liveReload = true
 }) {
-  if (!(0, import_shared15.isClientCompiler)(compiler)) {
+  if (!isClientCompiler(compiler)) {
     return;
   }
   new compiler.webpack.DefinePlugin({
@@ -1729,13 +1951,27 @@ function applyHMREntry({
     }).apply(compiler);
   }
 }
-var import_shared15, setupServerHooks, getDevMiddleware;
+var isClientCompiler, isNodeCompiler, setupServerHooks, getDevMiddleware;
 var init_devMiddleware = __esm({
   "src/server/devMiddleware.ts"() {
     "use strict";
-    import_shared15 = require("@rsbuild/shared");
+    init_helpers();
+    isClientCompiler = (compiler) => {
+      const { target } = compiler.options;
+      if (target) {
+        return Array.isArray(target) ? target.includes("web") : target === "web";
+      }
+      return false;
+    };
+    isNodeCompiler = (compiler) => {
+      const { target } = compiler.options;
+      if (target) {
+        return Array.isArray(target) ? target.includes("node") : target === "node";
+      }
+      return false;
+    };
     setupServerHooks = (compiler, hookCallbacks) => {
-      if ((0, import_shared15.isNodeCompiler)(compiler)) {
+      if (isNodeCompiler(compiler)) {
         return;
       }
       const { compile, invalid, done } = compiler.hooks;
@@ -1758,7 +1994,7 @@ var init_devMiddleware = __esm({
           }
           setupServerHooks(compiler, callbacks);
         };
-        (0, import_shared15.applyToCompiler)(multiCompiler, setupCompiler);
+        applyToCompiler(multiCompiler, setupCompiler);
         return webpackDevMiddleware(multiCompiler, restOptions);
       };
     };
@@ -1775,13 +2011,13 @@ async function createCompiler({
   context,
   rspackConfigs
 }) {
-  (0, import_shared16.debug)("create compiler");
+  import_rslog.logger.debug("create compiler");
   await context.hooks.onBeforeCreateCompiler.call({
     bundlerConfigs: rspackConfigs
   });
   if (!await isSatisfyRspackVersion(import_core3.rspack.rspackVersion)) {
     throw new Error(
-      `The current Rspack version does not meet the requirements, the minimum supported version of Rspack is ${import_shared16.color.green(
+      `The current Rspack version does not meet the requirements, the minimum supported version of Rspack is ${import_shared14.color.green(
         rspackMinVersion
       )}`
     );
@@ -1792,18 +2028,18 @@ async function createCompiler({
   let isCompiling = false;
   const logRspackVersion = () => {
     if (!isVersionLogged) {
-      (0, import_shared16.debug)(`Use Rspack v${import_core3.rspack.rspackVersion}`);
+      import_rslog.logger.debug(`Use Rspack v${import_core3.rspack.rspackVersion}`);
       isVersionLogged = true;
     }
   };
   compiler.hooks.watchRun.tap("rsbuild:compiling", () => {
     logRspackVersion();
     if (!isCompiling) {
-      import_shared16.logger.start("Compiling...");
+      import_rslog.logger.start("Compiling...");
     }
     isCompiling = true;
   });
-  if ((0, import_shared16.isProd)()) {
+  if ((0, import_shared14.isProd)()) {
     compiler.hooks.run.tap("rsbuild:run", logRspackVersion);
   }
   const done = async (stats) => {
@@ -1813,10 +2049,10 @@ async function createCompiler({
     });
     const printTime = (c, index) => {
       if (c.time) {
-        const time = (0, import_shared16.prettyTime)(c.time / 1e3);
+        const time = (0, import_shared14.prettyTime)(c.time / 1e3);
         const target = context.targets[index];
-        const name = import_shared16.TARGET_ID_MAP[target || "web"];
-        import_shared16.logger.ready(`${name} compiled in ${time}`);
+        const name = TARGET_ID_MAP[target || "web"];
+        import_rslog.logger.ready(`${name} compiled in ${time}`);
       }
     };
     if (!stats.hasErrors()) {
@@ -1830,12 +2066,12 @@ async function createCompiler({
     }
     const { message, level } = formatStats(stats, getStatsOptions(compiler));
     if (level === "error") {
-      import_shared16.logger.error(message);
+      import_rslog.logger.error(message);
     }
     if (level === "warning") {
-      import_shared16.logger.warn(message);
+      import_rslog.logger.warn(message);
     }
-    if ((0, import_shared16.isDev)()) {
+    if ((0, import_shared14.isDev)()) {
       await context.hooks.onDevCompileDone.call({
         isFirstCompile,
         stats
@@ -1844,14 +2080,14 @@ async function createCompiler({
     isCompiling = false;
     isFirstCompile = false;
   };
-  (0, import_shared16.onCompileDone)(
+  onCompileDone(
     compiler,
     done,
     // @ts-expect-error type mismatch
     import_core3.rspack.MultiStats
   );
   await context.hooks.onAfterCreateCompiler.call({ compiler });
-  (0, import_shared16.debug)("create compiler done");
+  import_rslog.logger.debug("create compiler done");
   return compiler;
 }
 async function createDevMiddleware(options, customCompiler) {
@@ -1871,25 +2107,28 @@ async function createDevMiddleware(options, customCompiler) {
     compiler
   };
 }
-var import_shared16, import_core3;
+var import_shared14, import_core3;
 var init_createCompiler = __esm({
   "src/provider/createCompiler.ts"() {
     "use strict";
-    import_shared16 = require("@rsbuild/shared");
+    import_shared14 = require("@rsbuild/shared");
     import_core3 = require("@rspack/core");
+    init_constants();
     init_helpers();
+    init_logger();
     init_initConfigs();
   }
 });
 
 // src/server/middlewares.ts
-var import_node_path9, import_node_url, import_shared17, faviconFallbackMiddleware, getStatusCodeColor, getRequestLoggerMiddleware, notFoundMiddleware, getHtmlFallbackMiddleware;
+var import_node_path9, import_node_url, import_shared15, faviconFallbackMiddleware, getStatusCodeColor, getRequestLoggerMiddleware, notFoundMiddleware, getHtmlFallbackMiddleware;
 var init_middlewares = __esm({
   "src/server/middlewares.ts"() {
     "use strict";
     import_node_path9 = __toESM(require("path"));
     import_node_url = require("url");
-    import_shared17 = require("@rsbuild/shared");
+    import_shared15 = require("@rsbuild/shared");
+    init_logger();
     faviconFallbackMiddleware = (req, res, next) => {
       if (req.url === "/favicon.ico") {
         res.statusCode = 204;
@@ -1900,16 +2139,16 @@ var init_middlewares = __esm({
     };
     getStatusCodeColor = (status) => {
       if (status >= 500) {
-        return import_shared17.color.red;
+        return import_shared15.color.red;
       }
       if (status >= 400) {
-        return import_shared17.color.yellow;
+        return import_shared15.color.yellow;
       }
       if (status >= 300) {
-        return import_shared17.color.cyan;
+        return import_shared15.color.cyan;
       }
       if (status >= 200) {
-        return import_shared17.color.green;
+        return import_shared15.color.green;
       }
       return (res) => res;
     };
@@ -1924,8 +2163,8 @@ var init_middlewares = __esm({
           const statusColor = getStatusCodeColor(status);
           const endAt = process.hrtime();
           const totalTime = (endAt[0] - _startAt[0]) * 1e3 + (endAt[1] - _startAt[1]) * 1e-6;
-          (0, import_shared17.debug)(
-            `${statusColor(status)} ${method} ${import_shared17.color.gray(url2)} ${import_shared17.color.gray(
+          import_rslog.logger.debug(
+            `${statusColor(status)} ${method} ${import_shared15.color.gray(url2)} ${import_shared15.color.gray(
               `${totalTime.toFixed(3)} ms`
             )}`
           );
@@ -1954,8 +2193,8 @@ var init_middlewares = __esm({
         try {
           pathname = (0, import_node_url.parse)(url2, false, true).pathname;
         } catch (err) {
-          import_shared17.logger.error(
-            new Error(`Invalid URL: ${import_shared17.color.yellow(url2)}`, { cause: err })
+          import_rslog.logger.error(
+            new Error(`Invalid URL: ${import_shared15.color.yellow(url2)}`, { cause: err })
           );
           return next();
         }
@@ -1967,10 +2206,10 @@ var init_middlewares = __esm({
           });
         };
         const rewrite = (newUrl, isFallback = false) => {
-          if (isFallback && (0, import_shared17.isDebug)()) {
-            (0, import_shared17.debug)(
-              `${req.method} ${import_shared17.color.gray(
-                `${req.url} ${import_shared17.color.yellow("fallback")} to ${newUrl}`
+          if (isFallback && import_rslog.logger.level === "verbose") {
+            import_rslog.logger.debug(
+              `${req.method} ${import_shared15.color.gray(
+                `${req.url} ${import_shared15.color.yellow("fallback")} to ${newUrl}`
               )}`
             );
           }
@@ -2036,18 +2275,18 @@ function formatProxyOptions(proxyOptions) {
       ret.push(opts);
     }
   }
-  const handleError = (err) => import_shared18.logger.error(err);
+  const handleError = (err) => import_rslog.logger.error(err);
   for (const opts of ret) {
     opts.onError ??= handleError;
   }
   return ret;
 }
-var import_shared18, import_http_proxy_middleware, createProxyMiddleware;
+var import_http_proxy_middleware, createProxyMiddleware;
 var init_proxy = __esm({
   "src/server/proxy.ts"() {
     "use strict";
-    import_shared18 = require("@rsbuild/shared");
     import_http_proxy_middleware = require("@rsbuild/shared/http-proxy-middleware");
+    init_logger();
     createProxyMiddleware = (proxyOptions) => {
       const formattedOptionsList = formatProxyOptions(proxyOptions);
       const proxyMiddlewares = [];
@@ -2087,14 +2326,14 @@ var init_proxy = __esm({
 });
 
 // src/server/getDevMiddlewares.ts
-var import_node_path10, import_node_url2, import_shared19, applySetupMiddlewares, applyDefaultMiddlewares, getMiddlewares;
+var import_node_path10, import_node_url2, applySetupMiddlewares, applyDefaultMiddlewares, getMiddlewares;
 var init_getDevMiddlewares = __esm({
   "src/server/getDevMiddlewares.ts"() {
     "use strict";
     import_node_path10 = require("path");
     import_node_url2 = __toESM(require("url"));
-    import_shared19 = require("@rsbuild/shared");
     init_config();
+    init_logger();
     init_middlewares();
     applySetupMiddlewares = (dev, compileMiddlewareAPI) => {
       const setupMiddlewares = dev.setupMiddlewares || [];
@@ -2212,7 +2451,7 @@ var init_getDevMiddlewares = __esm({
     getMiddlewares = async (options) => {
       const middlewares = [];
       const { compileMiddlewareAPI } = options;
-      if ((0, import_shared19.isDebug)()) {
+      if (import_rslog.logger.level === "verbose") {
         middlewares.push(await getRequestLoggerMiddleware());
       }
       const { before, after } = applySetupMiddlewares(
@@ -2240,7 +2479,7 @@ var init_getDevMiddlewares = __esm({
 function getURLMessages(urls, routes) {
   if (routes.length === 1) {
     return urls.map(
-      ({ label, url: url2 }) => `  ${`> ${label.padEnd(10)}`}${import_shared20.color.cyan(
+      ({ label, url: url2 }) => `  ${`> ${label.padEnd(10)}`}${import_shared16.color.cyan(
         normalizeUrl(`${url2}${routes[0].pathname}`)
       )}
 `
@@ -2255,9 +2494,9 @@ function getURLMessages(urls, routes) {
     message += `  ${`> ${label}`}
 `;
     for (const r of routes) {
-      message += `  ${import_shared20.color.dim("-")} ${import_shared20.color.dim(
+      message += `  ${import_shared16.color.dim("-")} ${import_shared16.color.dim(
         r.entryName.padEnd(maxNameLength + 4)
-      )}${import_shared20.color.cyan(normalizeUrl(`${url2}${r.pathname}`))}
+      )}${import_shared16.color.cyan(normalizeUrl(`${url2}${r.pathname}`))}
 `;
     }
   });
@@ -2274,7 +2513,7 @@ function printServerURLs({
     return;
   }
   let urls = originalUrls;
-  if ((0, import_shared20.isFunction)(printUrls)) {
+  if ((0, import_shared16.isFunction)(printUrls)) {
     const newUrls = printUrls({
       urls: urls.map((item) => item.url),
       port,
@@ -2298,17 +2537,18 @@ function printServerURLs({
     return;
   }
   const message = getURLMessages(urls, routes);
-  import_shared20.logger.log(message);
+  import_rslog.logger.log(message);
   return message;
 }
-var import_node_net, import_node_os, import_shared20, normalizeUrl, formatPrefix, formatRoutes, HMR_SOCK_PATH, getPort, getServerConfig, getDevConfig, getIpv4Interfaces, isLoopbackHost, getHostInUrl, concatUrl, LOCAL_LABEL, NETWORK_LABEL, getUrlLabel, getAddressUrls;
+var import_node_net, import_node_os, import_shared16, normalizeUrl, formatPrefix, formatRoutes, HMR_SOCK_PATH, getPort, getServerConfig, getDevConfig, getIpv4Interfaces, isLoopbackHost, getHostInUrl, concatUrl, LOCAL_LABEL, NETWORK_LABEL, getUrlLabel, getAddressUrls;
 var init_helper = __esm({
   "src/server/helper.ts"() {
     "use strict";
     import_node_net = __toESM(require("net"));
     import_node_os = __toESM(require("os"));
-    import_shared20 = require("@rsbuild/shared");
+    import_shared16 = require("@rsbuild/shared");
     init_constants();
+    init_logger();
     normalizeUrl = (url2) => url2.replace(/([^:]\/)\/+/g, "$1");
     formatPrefix = (prefix) => {
       if (!prefix) {
@@ -2372,8 +2612,8 @@ var init_helper = __esm({
           );
         }
         if (!silent) {
-          import_shared20.logger.info(
-            `Port ${original} is in use, ${import_shared20.color.yellow(`using port ${port}.`)}
+          import_rslog.logger.info(
+            `Port ${original} is in use, ${import_shared16.color.yellow(`using port ${port}.`)}
 `
           );
         }
@@ -2410,7 +2650,7 @@ var init_helper = __esm({
         writeToDisk: false,
         liveReload: true
       };
-      const devConfig = config.dev ? (0, import_shared20.deepmerge)(defaultDevConfig, config.dev) : defaultDevConfig;
+      const devConfig = config.dev ? (0, import_shared16.deepmerge)(defaultDevConfig, config.dev) : defaultDevConfig;
       return devConfig;
     };
     getIpv4Interfaces = () => {
@@ -2596,12 +2836,12 @@ var init_watchFiles = __esm({
 });
 
 // src/server/socketServer.ts
-var import_shared21, SocketServer;
+var SocketServer;
 var init_socketServer = __esm({
   "src/server/socketServer.ts"() {
     "use strict";
-    import_shared21 = require("@rsbuild/shared");
     init_helpers();
+    init_logger();
     SocketServer = class {
       constructor(options) {
         __publicField(this, "wsServer");
@@ -2627,7 +2867,7 @@ var init_socketServer = __esm({
           path: this.options.client?.path
         });
         this.wsServer.on("error", (err) => {
-          import_shared21.logger.error(err);
+          import_rslog.logger.error(err);
         });
         this.timer = setInterval(() => {
           for (const socket of this.wsServer.clients) {
@@ -2848,10 +3088,10 @@ async function createDevServer(options, createDevMiddleware2, config, {
   getPortSilently,
   runCompile = true
 } = {}) {
-  if (!(0, import_shared22.getNodeEnv)()) {
-    (0, import_shared22.setNodeEnv)("development");
+  if (!(0, import_shared17.getNodeEnv)()) {
+    (0, import_shared17.setNodeEnv)("development");
   }
-  (0, import_shared22.debug)("create dev server");
+  import_rslog.logger.debug("create dev server");
   const serverConfig = config.server;
   const { port, host, https } = await getServerConfig({
     config,
@@ -2878,7 +3118,7 @@ async function createDevServer(options, createDevMiddleware2, config, {
       customCompiler
     );
     const { CompilerDevMiddleware: CompilerDevMiddleware2 } = await Promise.resolve().then(() => (init_compilerDevMiddleware(), compilerDevMiddleware_exports));
-    const publicPaths = (0, import_shared22.isMultiCompiler)(compiler) ? compiler.compilers.map(import_shared22.getPublicPathFromCompiler) : [(0, import_shared22.getPublicPathFromCompiler)(compiler)];
+    const publicPaths = isMultiCompiler(compiler) ? compiler.compilers.map(import_shared17.getPublicPathFromCompiler) : [(0, import_shared17.getPublicPathFromCompiler)(compiler)];
     const compilerDevMiddleware = new CompilerDevMiddleware2({
       dev: devConfig,
       server: serverConfig,
@@ -2886,7 +3126,7 @@ async function createDevServer(options, createDevMiddleware2, config, {
       devMiddleware
     });
     await compilerDevMiddleware.init();
-    outputFileSystem = ((0, import_shared22.isMultiCompiler)(compiler) ? compiler.compilers[0].outputFileSystem : compiler.outputFileSystem) || import_node_fs3.default;
+    outputFileSystem = (isMultiCompiler(compiler) ? compiler.compilers[0].outputFileSystem : compiler.outputFileSystem) || import_node_fs3.default;
     return {
       middleware: compilerDevMiddleware.middleware,
       sockWrite: (...args) => compilerDevMiddleware.sockWrite(...args),
@@ -2950,7 +3190,7 @@ async function createDevServer(options, createDevMiddleware2, config, {
         serverConfig,
         middlewares
       });
-      (0, import_shared22.debug)("listen dev server");
+      import_rslog.logger.debug("listen dev server");
       return new Promise((resolve) => {
         httpServer.listen(
           {
@@ -2963,7 +3203,7 @@ async function createDevServer(options, createDevMiddleware2, config, {
             }
             middlewares.use(notFoundMiddleware);
             httpServer.on("upgrade", devMiddlewares.onUpgrade);
-            (0, import_shared22.debug)("listen dev server done");
+            import_rslog.logger.debug("listen dev server done");
             await server.afterListen();
             const closeServer = async () => {
               await server.close();
@@ -2994,16 +3234,18 @@ async function createDevServer(options, createDevMiddleware2, config, {
       await fileWatcher?.close();
     }
   };
-  (0, import_shared22.debug)("create dev server done");
+  import_rslog.logger.debug("create dev server done");
   return server;
 }
-var import_node_fs3, import_shared22;
+var import_node_fs3, import_shared17;
 var init_devServer = __esm({
   "src/server/devServer.ts"() {
     "use strict";
     import_node_fs3 = __toESM(require("fs"));
-    import_shared22 = require("@rsbuild/shared");
+    import_shared17 = require("@rsbuild/shared");
     init_constants();
+    init_helpers();
+    init_logger();
     init_getDevMiddlewares();
     init_helper();
     init_httpServer();
@@ -3018,17 +3260,19 @@ var build_exports = {};
 __export(build_exports, {
   build: () => build
 });
-var import_shared23, import_core4, build;
+var import_shared18, import_core4, build;
 var init_build = __esm({
   "src/provider/build.ts"() {
     "use strict";
-    import_shared23 = require("@rsbuild/shared");
+    import_shared18 = require("@rsbuild/shared");
     import_core4 = require("@rspack/core");
+    init_helpers();
+    init_logger();
     init_createCompiler();
     init_initConfigs();
     build = async (initOptions, { mode = "production", watch, compiler: customCompiler } = {}) => {
-      if (!(0, import_shared23.getNodeEnv)()) {
-        (0, import_shared23.setNodeEnv)(mode);
+      if (!(0, import_shared18.getNodeEnv)()) {
+        (0, import_shared18.setNodeEnv)(mode);
       }
       const { context } = initOptions;
       let compiler;
@@ -3052,7 +3296,7 @@ var init_build = __esm({
         isFirstCompile = false;
         await p;
       };
-      (0, import_shared23.onCompileDone)(
+      onCompileDone(
         compiler,
         onDone,
         // @ts-expect-error type mismatch
@@ -3061,7 +3305,7 @@ var init_build = __esm({
       if (watch) {
         compiler.watch({}, (err) => {
           if (err) {
-            import_shared23.logger.error(err);
+            import_rslog.logger.error(err);
           }
         });
         return;
@@ -3074,7 +3318,7 @@ var init_build = __esm({
           } else {
             compiler.close((closeErr) => {
               if (closeErr) {
-                import_shared23.logger.error(closeErr);
+                import_rslog.logger.error(closeErr);
               }
               resolve({ stats });
             });
@@ -3169,22 +3413,30 @@ var basic_exports = {};
 __export(basic_exports, {
   pluginBasic: () => pluginBasic
 });
-var import_node_path11, import_shared24, pluginBasic;
+var import_node_path11, import_shared19, getJsSourceMap, pluginBasic;
 var init_basic = __esm({
   "src/plugins/basic.ts"() {
     "use strict";
     import_node_path11 = __toESM(require("path"));
-    import_shared24 = require("@rsbuild/shared");
+    import_shared19 = require("@rsbuild/shared");
+    init_constants();
+    getJsSourceMap = (config) => {
+      const { sourceMap } = config.output;
+      if (sourceMap.js === void 0) {
+        return (0, import_shared19.isProd)() ? false : "cheap-module-source-map";
+      }
+      return sourceMap.js;
+    };
     pluginBasic = () => ({
       name: "rsbuild:basic",
       setup(api) {
         api.modifyBundlerChain(
-          (chain, { env, isProd: isProd6, target, bundler, CHAIN_ID: CHAIN_ID3 }) => {
+          (chain, { env, isProd: isProd7, target, bundler, CHAIN_ID: CHAIN_ID3 }) => {
             const config = api.getNormalizedConfig();
-            chain.name(import_shared24.TARGET_ID_MAP[target]);
-            chain.devtool((0, import_shared24.getJsSourceMap)(config));
+            chain.name(TARGET_ID_MAP[target]);
+            chain.devtool(getJsSourceMap(config));
             chain.context(api.context.rootPath);
-            chain.mode(isProd6 ? "production" : "development");
+            chain.mode(isProd7 ? "production" : "development");
             chain.merge({
               infrastructureLogging: {
                 // Using `error` level to avoid `cache.PackFileCacheStrategy` logs
@@ -3197,9 +3449,9 @@ var init_basic = __esm({
                 exportsPresence: "error"
               }
             });
-            const isMinimize = isProd6 && config.output.minify !== false;
+            const isMinimize = isProd7 && config.output.minify !== false;
             chain.optimization.minimize(isMinimize);
-            const usingHMR = (0, import_shared24.isUsingHMR)(config, { target, isProd: isProd6 });
+            const usingHMR = (0, import_shared19.isUsingHMR)(config, { target, isProd: isProd7 });
             if (usingHMR) {
               chain.plugin(CHAIN_ID3.PLUGIN.HMR).use(bundler.HotModuleReplacementPlugin);
             }
@@ -3225,13 +3477,13 @@ __export(cache_exports, {
 async function validateCache(cacheDirectory, buildDependencies) {
   const configFile = (0, import_node_path12.join)(cacheDirectory, "buildDependencies.json");
   if (await isFileExists(configFile)) {
-    const prevBuildDependencies = await import_shared25.fse.readJSON(configFile);
+    const prevBuildDependencies = await import_shared20.fse.readJSON(configFile);
     if (JSON.stringify(prevBuildDependencies) === JSON.stringify(buildDependencies)) {
       return;
     }
-    await import_shared25.fse.remove(cacheDirectory);
+    await import_shared20.fse.remove(cacheDirectory);
   }
-  await import_shared25.fse.outputJSON(configFile, buildDependencies);
+  await import_shared20.fse.outputJSON(configFile, buildDependencies);
 }
 function getDigestHash(digest) {
   const fsHash = import_node_crypto.default.createHash("md5");
@@ -3270,13 +3522,13 @@ async function getBuildDependencies(context, config) {
   }
   return buildDependencies;
 }
-var import_node_crypto, import_node_path12, import_shared25, pluginCache;
+var import_node_crypto, import_node_path12, import_shared20, pluginCache;
 var init_cache = __esm({
   "src/plugins/cache.ts"() {
     "use strict";
     import_node_crypto = __toESM(require("crypto"));
     import_node_path12 = require("path");
-    import_shared25 = require("@rsbuild/shared");
+    import_shared20 = require("@rsbuild/shared");
     init_helpers();
     pluginCache = () => ({
       name: "rsbuild:cache",
@@ -3316,11 +3568,11 @@ var target_exports = {};
 __export(target_exports, {
   pluginTarget: () => pluginTarget
 });
-var import_shared26, pluginTarget;
+var import_shared21, pluginTarget;
 var init_target = __esm({
   "src/plugins/target.ts"() {
     "use strict";
-    import_shared26 = require("@rsbuild/shared");
+    import_shared21 = require("@rsbuild/shared");
     pluginTarget = () => ({
       name: "rsbuild:target",
       setup(api) {
@@ -3332,12 +3584,12 @@ var init_target = __esm({
               return;
             }
             const config = api.getNormalizedConfig();
-            const browserslist = await (0, import_shared26.getBrowserslistWithDefault)(
+            const browserslist = await (0, import_shared21.getBrowserslistWithDefault)(
               api.context.rootPath,
               config,
               target
             );
-            const esVersion = (0, import_shared26.browserslistToESVersion)(browserslist);
+            const esVersion = (0, import_shared21.browserslistToESVersion)(browserslist);
             if (target === "web-worker" || target === "service-worker") {
               chain.target(["webworker", `es${esVersion}`]);
               return;
@@ -3381,16 +3633,16 @@ async function applyCSSRule({
   rule,
   config,
   context,
-  utils: { target, isProd: isProd6, CHAIN_ID: CHAIN_ID3 },
+  utils: { target, isProd: isProd7, CHAIN_ID: CHAIN_ID3 },
   importLoaders = 1
 }) {
-  const browserslist = await (0, import_shared27.getBrowserslistWithDefault)(
+  const browserslist = await (0, import_shared22.getBrowserslistWithDefault)(
     context.rootPath,
     config,
     target
   );
   const enableExtractCSS = isUseCssExtract(config, target);
-  const localIdentName = getCSSModulesLocalIdentName(config, isProd6);
+  const localIdentName = getCSSModulesLocalIdentName(config, isProd7);
   const cssLoaderOptions = getCSSLoaderOptions({
     config,
     importLoaders,
@@ -3401,7 +3653,7 @@ async function applyCSSRule({
     if (enableExtractCSS) {
       rule.use(CHAIN_ID3.USE.MINI_CSS_EXTRACT).loader(getCssExtractPlugin().loader).options(config.tools.cssExtract.loaderOptions).end();
     } else {
-      const styleLoaderOptions = (0, import_shared27.reduceConfigs)({
+      const styleLoaderOptions = (0, import_shared22.reduceConfigs)({
         initial: {},
         config: config.tools.styleLoader
       });
@@ -3422,19 +3674,19 @@ async function applyCSSRule({
   rule.merge({ sideEffects: true });
   rule.resolve.preferRelative(true);
 }
-var import_node_path13, import_shared27, enableNativeCss, isUseCssExtract, getCSSModulesLocalIdentName, normalizeCssLoaderOptions, userPostcssrcCache, applyAutoprefixer, getPostcssLoaderOptions, getCSSLoaderOptions, pluginCss;
+var import_node_path13, import_shared22, enableNativeCss, isUseCssExtract, getCSSModulesLocalIdentName, normalizeCssLoaderOptions, userPostcssrcCache, applyAutoprefixer, getPostcssLoaderOptions, getCSSLoaderOptions, pluginCss;
 var init_css = __esm({
   "src/plugins/css.ts"() {
     "use strict";
     import_node_path13 = __toESM(require("path"));
-    import_shared27 = require("@rsbuild/shared");
+    import_shared22 = require("@rsbuild/shared");
     init_constants();
     init_helpers();
     init_pluginHelper();
     enableNativeCss = (config) => !config.output.injectStyles;
     isUseCssExtract = (config, target) => !config.output.injectStyles && target !== "node" && target !== "web-worker";
-    getCSSModulesLocalIdentName = (config, isProd6) => config.output.cssModules.localIdentName || // Using shorter classname in production to reduce bundle size
-    (isProd6 ? "[local]-[hash:base64:6]" : "[path][name]__[local]-[hash:base64:6]");
+    getCSSModulesLocalIdentName = (config, isProd7) => config.output.cssModules.localIdentName || // Using shorter classname in production to reduce bundle size
+    (isProd7 ? "[local]-[hash:base64:6]" : "[path][name]__[local]-[hash:base64:6]");
     normalizeCssLoaderOptions = (options, exportOnlyLocals) => {
       if (options.modules && exportOnlyLocals) {
         let { modules } = options;
@@ -3461,17 +3713,17 @@ var init_css = __esm({
     userPostcssrcCache = /* @__PURE__ */ new Map();
     applyAutoprefixer = async (plugins, browserslist, config) => {
       const pluginObjects = plugins.map(
-        (plugin) => (0, import_shared27.isFunction)(plugin) ? plugin({}) : plugin
+        (plugin) => (0, import_shared22.isFunction)(plugin) ? plugin({}) : plugin
       );
       const hasAutoprefixer = pluginObjects.some((pluginObject) => {
-        if ((0, import_shared27.isPlainObject)(pluginObject) && "postcssPlugin" in pluginObject) {
+        if ((0, import_shared22.isPlainObject)(pluginObject) && "postcssPlugin" in pluginObject) {
           return pluginObject.postcssPlugin === "autoprefixer";
         }
         return false;
       });
       if (!hasAutoprefixer) {
         const { default: autoprefixer } = await import("@rsbuild/shared/autoprefixer");
-        const autoprefixerOptions = (0, import_shared27.reduceConfigs)({
+        const autoprefixerOptions = (0, import_shared22.reduceConfigs)({
           initial: {
             flexbox: "no-2009",
             overrideBrowserslist: browserslist
@@ -3511,7 +3763,7 @@ var init_css = __esm({
         },
         sourceMap: config.output.sourceMap.css
       };
-      const mergedConfig = (0, import_shared27.reduceConfigsWithContext)({
+      const mergedConfig = (0, import_shared22.reduceConfigsWithContext)({
         initial: defaultPostcssConfig,
         config: config.tools.postcss,
         ctx: utils
@@ -3538,10 +3790,10 @@ var init_css = __esm({
         },
         sourceMap: config.output.sourceMap.css
       };
-      const mergedCssLoaderOptions = (0, import_shared27.reduceConfigs)({
+      const mergedCssLoaderOptions = (0, import_shared22.reduceConfigs)({
         initial: defaultOptions2,
         config: config.tools.cssLoader,
-        mergeFn: import_shared27.deepmerge
+        mergeFn: import_shared22.deepmerge
       });
       const cssLoaderOptions = normalizeCssLoaderOptions(
         mergedCssLoaderOptions,
@@ -3581,13 +3833,13 @@ __export(output_exports, {
   pluginOutput: () => pluginOutput
 });
 function getPublicPath({
-  isProd: isProd6,
+  isProd: isProd7,
   config,
   context
 }) {
   const { dev, output } = config;
-  let publicPath = import_shared28.DEFAULT_ASSET_PREFIX;
-  if (isProd6) {
+  let publicPath = import_shared23.DEFAULT_ASSET_PREFIX;
+  if (isProd7) {
     if (typeof output.assetPrefix === "string") {
       publicPath = output.assetPrefix;
     }
@@ -3606,12 +3858,12 @@ function getPublicPath({
   }
   return formatPublicPath(publicPath);
 }
-var import_node_path14, import_shared28, import_core5, pluginOutput;
+var import_node_path14, import_shared23, import_core5, pluginOutput;
 var init_output = __esm({
   "src/plugins/output.ts"() {
     "use strict";
     import_node_path14 = require("path");
-    import_shared28 = require("@rsbuild/shared");
+    import_shared23 = require("@rsbuild/shared");
     import_core5 = require("@rspack/core");
     init_constants();
     init_helpers();
@@ -3621,16 +3873,16 @@ var init_output = __esm({
       name: "rsbuild:output",
       setup(api) {
         api.modifyBundlerChain(
-          async (chain, { CHAIN_ID: CHAIN_ID3, target, isProd: isProd6, isServer, isServiceWorker }) => {
+          async (chain, { CHAIN_ID: CHAIN_ID3, target, isProd: isProd7, isServer, isServiceWorker }) => {
             const config = api.getNormalizedConfig();
             const publicPath = getPublicPath({
               config,
-              isProd: isProd6,
+              isProd: isProd7,
               context: api.context
             });
-            const jsPath = (0, import_shared28.getDistPath)(config, "js");
-            const jsAsyncPath = (0, import_shared28.getDistPath)(config, "jsAsync");
-            const jsFilename = (0, import_shared28.getFilename)(config, "js", isProd6);
+            const jsPath = config.output.distPath.js;
+            const jsAsyncPath = config.output.distPath.jsAsync ?? (jsPath ? `${jsPath}/async` : "async");
+            const jsFilename = getFilename(config, "js", isProd7);
             const isJsFilenameFn = typeof jsFilename === "function";
             chain.output.path(api.context.distPath).filename(
               isJsFilenameFn ? (...args) => {
@@ -3644,14 +3896,14 @@ var init_output = __esm({
               } : import_node_path14.posix.join(jsAsyncPath, jsFilename)
             ).publicPath(publicPath).pathinfo(false).hashFunction("xxhash64");
             if (isServer) {
-              const serverPath = (0, import_shared28.getDistPath)(config, "server");
+              const serverPath = config.output.distPath.server;
               chain.output.path(import_node_path14.posix.join(api.context.distPath, serverPath)).filename("[name].js").chunkFilename("[name].js").library({
                 ...chain.output.get("library") || {},
                 type: "commonjs2"
               });
             }
             if (isServiceWorker) {
-              const workerPath = (0, import_shared28.getDistPath)(config, "worker");
+              const workerPath = config.output.distPath.worker;
               const filename = import_node_path14.posix.join(workerPath, "[name].js");
               chain.output.filename(filename).chunkFilename(filename);
             }
@@ -3662,9 +3914,9 @@ var init_output = __esm({
             }
             if (isUseCssExtract(config, target)) {
               const extractPluginOptions = config.tools.cssExtract.pluginOptions;
-              const cssPath = (0, import_shared28.getDistPath)(config, "css");
-              const cssFilename = (0, import_shared28.getFilename)(config, "css", isProd6);
-              const cssAsyncPath = (0, import_shared28.getDistPath)(config, "cssAsync");
+              const cssPath = config.output.distPath.css;
+              const cssFilename = getFilename(config, "css", isProd7);
+              const cssAsyncPath = config.output.distPath.cssAsync ?? (cssPath ? `${cssPath}/async` : "async");
               chain.plugin(CHAIN_ID3.PLUGIN.MINI_CSS_EXTRACT).use(getCssExtractPlugin(), [
                 {
                   filename: import_node_path14.posix.join(cssPath, cssFilename),
@@ -3713,13 +3965,13 @@ function applyAlias({
   if (!alias) {
     return;
   }
-  const mergedAlias = (0, import_shared29.reduceConfigsWithContext)({
+  const mergedAlias = (0, import_shared24.reduceConfigsWithContext)({
     initial: {},
     config: alias,
     ctx: { target }
   });
   for (const name of Object.keys(mergedAlias)) {
-    const values = (0, import_shared29.castArray)(mergedAlias[name]);
+    const values = (0, import_shared24.castArray)(mergedAlias[name]);
     const formattedValues = values.map((value) => {
       if (typeof value === "string" && value.startsWith(".")) {
         return ensureAbsolutePath(rootPath, value);
@@ -3732,11 +3984,11 @@ function applyAlias({
     );
   }
 }
-var import_shared29, pluginResolve;
+var import_shared24, pluginResolve;
 var init_resolve = __esm({
   "src/plugins/resolve.ts"() {
     "use strict";
-    import_shared29 = require("@rsbuild/shared");
+    import_shared24 = require("@rsbuild/shared");
     init_helpers();
     pluginResolve = () => ({
       name: "rsbuild:resolve",
@@ -3784,7 +4036,7 @@ async function printHeader(longestFileLength, longestLabelLength) {
     }
     return `${prev + curLabel}    `;
   }, "  ");
-  import_shared31.logger.log(import_shared31.color.bold(import_shared31.color.blue(headerRow)));
+  import_rslog.logger.log(import_shared26.color.bold(import_shared26.color.blue(headerRow)));
 }
 async function printFileSizes(config, stats, rootPath) {
   if (config.detail === false && config.total === false) {
@@ -3793,7 +4045,7 @@ async function printFileSizes(config, stats, rootPath) {
   const { default: gzipSize } = await import("@rsbuild/shared/gzip-size");
   const formatAsset = (asset, distPath, distFolder) => {
     const fileName = asset.name.split("?")[0];
-    const contents = import_shared30.fse.readFileSync(import_node_path15.default.join(distPath, fileName));
+    const contents = import_shared25.fse.readFileSync(import_node_path15.default.join(distPath, fileName));
     const size = contents.length;
     const gzippedSize = gzipSize.sync(contents);
     return {
@@ -3835,7 +4087,7 @@ async function printFileSizes(config, stats, rootPath) {
     return;
   }
   assets.sort((a, b) => a.size - b.size);
-  import_shared31.logger.info("Production file sizes:\n");
+  import_rslog.logger.info("Production file sizes:\n");
   const longestLabelLength = Math.max(...assets.map((a) => a.sizeLabel.length));
   const longestFileLength = Math.max(
     ...assets.map((a) => (a.folder + import_node_path15.default.sep + a.name).length)
@@ -3857,60 +4109,61 @@ async function printFileSizes(config, stats, rootPath) {
         const rightPadding = " ".repeat(longestLabelLength - sizeLength);
         sizeLabel += rightPadding;
       }
-      let fileNameLabel = import_shared31.color.dim(asset.folder + import_node_path15.default.sep) + coloringAssetName(asset.name);
+      let fileNameLabel = import_shared26.color.dim(asset.folder + import_node_path15.default.sep) + coloringAssetName(asset.name);
       if (fileNameLength < longestFileLength) {
         const rightPadding = " ".repeat(longestFileLength - fileNameLength);
         fileNameLabel += rightPadding;
       }
-      import_shared31.logger.log(`  ${fileNameLabel}    ${sizeLabel}    ${gzipSizeLabel}`);
+      import_rslog.logger.log(`  ${fileNameLabel}    ${sizeLabel}    ${gzipSizeLabel}`);
     }
   }
   if (config.total !== false) {
-    const totalSizeLabel = `${import_shared31.color.bold(
-      import_shared31.color.blue("Total size:")
+    const totalSizeLabel = `${import_shared26.color.bold(
+      import_shared26.color.blue("Total size:")
     )}  ${calcFileSize(totalSize)}`;
-    const gzippedSizeLabel = `${import_shared31.color.bold(
-      import_shared31.color.blue("Gzipped size:")
+    const gzippedSizeLabel = `${import_shared26.color.bold(
+      import_shared26.color.blue("Gzipped size:")
     )}  ${calcFileSize(totalGzipSize)}`;
-    import_shared31.logger.log(`
+    import_rslog.logger.log(`
   ${totalSizeLabel}
   ${gzippedSizeLabel}
 `);
   }
 }
-var import_node_path15, import_shared30, import_shared31, filterAsset, getAssetColor, calcFileSize, coloringAssetName, pluginFileSize;
+var import_node_path15, import_shared25, import_shared26, filterAsset, getAssetColor, calcFileSize, coloringAssetName, pluginFileSize;
 var init_fileSize = __esm({
   "src/plugins/fileSize.ts"() {
     "use strict";
     import_node_path15 = __toESM(require("path"));
-    import_shared30 = require("@rsbuild/shared");
-    import_shared31 = require("@rsbuild/shared");
+    import_shared25 = require("@rsbuild/shared");
+    import_shared26 = require("@rsbuild/shared");
     init_constants();
+    init_logger();
     filterAsset = (asset) => !/\.map$/.test(asset) && !/\.LICENSE\.txt$/.test(asset);
     getAssetColor = (size) => {
       if (size > 300 * 1e3) {
-        return import_shared31.color.red;
+        return import_shared26.color.red;
       }
       if (size > 100 * 1e3) {
-        return import_shared31.color.yellow;
+        return import_shared26.color.yellow;
       }
-      return import_shared31.color.green;
+      return import_shared26.color.green;
     };
     calcFileSize = (len) => {
       const val = len / 1e3;
       return `${val.toFixed(val < 1 ? 2 : 1)} kB`;
     };
     coloringAssetName = (assetName) => {
-      if (import_shared30.JS_REGEX.test(assetName)) {
-        return import_shared31.color.cyan(assetName);
+      if (import_shared25.JS_REGEX.test(assetName)) {
+        return import_shared26.color.cyan(assetName);
       }
       if (CSS_REGEX.test(assetName)) {
-        return import_shared31.color.yellow(assetName);
+        return import_shared26.color.yellow(assetName);
       }
       if (HTML_REGEX.test(assetName)) {
-        return import_shared31.color.green(assetName);
+        return import_shared26.color.green(assetName);
       }
-      return import_shared31.color.magenta(assetName);
+      return import_shared26.color.magenta(assetName);
     };
     pluginFileSize = () => ({
       name: "rsbuild:file-size",
@@ -3932,8 +4185,8 @@ var init_fileSize = __esm({
                 api.context.rootPath
               );
             } catch (err) {
-              import_shared31.logger.warn("Failed to print file size.");
-              import_shared31.logger.warn(err);
+              import_rslog.logger.warn("Failed to print file size.");
+              import_rslog.logger.warn(err);
             }
           }
         });
@@ -3947,15 +4200,16 @@ var cleanOutput_exports = {};
 __export(cleanOutput_exports, {
   pluginCleanOutput: () => pluginCleanOutput
 });
-var import_node_path16, import_shared32, emptyDir, addTrailingSep, isStrictSubdir, pluginCleanOutput;
+var import_node_path16, import_shared27, emptyDir, addTrailingSep, isStrictSubdir, pluginCleanOutput;
 var init_cleanOutput = __esm({
   "src/plugins/cleanOutput.ts"() {
     "use strict";
     import_node_path16 = require("path");
-    import_shared32 = require("@rsbuild/shared");
+    import_shared27 = require("@rsbuild/shared");
+    init_logger();
     emptyDir = async (dir) => {
-      if (await import_shared32.fse.pathExists(dir)) {
-        await import_shared32.fse.emptyDir(dir);
+      if (await import_shared27.fse.pathExists(dir)) {
+        await import_shared27.fse.emptyDir(dir);
       }
     };
     addTrailingSep = (dir) => dir.endsWith(import_node_path16.sep) ? dir : dir + import_node_path16.sep;
@@ -3974,14 +4228,14 @@ var init_cleanOutput = __esm({
           if (cleanDistPath === void 0) {
             cleanDistPath = isStrictSubdir(rootPath, distPath);
             if (!cleanDistPath) {
-              import_shared32.logger.warn(
+              import_rslog.logger.warn(
                 "The dist path is not a subdir of root path, Rsbuild will not empty it."
               );
-              import_shared32.logger.warn(
-                `Please set ${import_shared32.color.yellow("`output.cleanDistPath`")} config manually.`
+              import_rslog.logger.warn(
+                `Please set ${import_shared27.color.yellow("`output.cleanDistPath`")} config manually.`
               );
-              import_shared32.logger.warn(`Current root path: ${import_shared32.color.dim(rootPath)}`);
-              import_shared32.logger.warn(`Current dist path: ${import_shared32.color.dim(distPath)}`);
+              import_rslog.logger.warn(`Current root path: ${import_shared27.color.dim(rootPath)}`);
+              import_rslog.logger.warn(`Current dist path: ${import_shared27.color.dim(distPath)}`);
             }
           }
           if (cleanDistPath) {
@@ -4008,13 +4262,13 @@ function getRegExpForExts(exts) {
     "i"
   );
 }
-var import_node_path17, import_shared33, chainStaticAssetRule, pluginAsset;
+var import_node_path17, chainStaticAssetRule, pluginAsset;
 var init_asset = __esm({
   "src/plugins/asset.ts"() {
     "use strict";
     import_node_path17 = __toESM(require("path"));
-    import_shared33 = require("@rsbuild/shared");
     init_constants();
+    init_helpers();
     chainStaticAssetRule = ({
       emit,
       rule,
@@ -4039,12 +4293,12 @@ var init_asset = __esm({
     pluginAsset = () => ({
       name: "rsbuild:asset",
       setup(api) {
-        api.modifyBundlerChain((chain, { isProd: isProd6, target }) => {
+        api.modifyBundlerChain((chain, { isProd: isProd7, target }) => {
           const config = api.getNormalizedConfig();
           const createAssetRule = (assetType, exts, emit2) => {
             const regExp = getRegExpForExts(exts);
-            const distDir = (0, import_shared33.getDistPath)(config, assetType);
-            const filename = (0, import_shared33.getFilename)(config, assetType, isProd6);
+            const distDir = config.output.distPath[assetType];
+            const filename = getFilename(config, assetType, isProd7);
             const { dataUriLimit } = config.output;
             const maxSize = typeof dataUriLimit === "number" ? dataUriLimit : dataUriLimit[assetType];
             const rule = chain.module.rule(assetType).test(regExp);
@@ -4078,24 +4332,24 @@ __export(minimize_exports, {
   parseMinifyOptions: () => parseMinifyOptions,
   pluginMinimize: () => pluginMinimize
 });
-var import_shared34, import_core6, getSwcMinimizerOptions, parseMinifyOptions, pluginMinimize;
+var import_shared28, import_core6, getSwcMinimizerOptions, parseMinifyOptions, pluginMinimize;
 var init_minimize = __esm({
   "src/plugins/minimize.ts"() {
     "use strict";
-    import_shared34 = require("@rsbuild/shared");
+    import_shared28 = require("@rsbuild/shared");
     import_core6 = require("@rspack/core");
     getSwcMinimizerOptions = (config) => {
       const options = {};
       const { removeConsole } = config.performance;
       if (removeConsole === true) {
         options.compress = {
-          ...(0, import_shared34.isObject)(options.compress) ? options.compress : {},
+          ...(0, import_shared28.isObject)(options.compress) ? options.compress : {},
           drop_console: true
         };
       } else if (Array.isArray(removeConsole)) {
         const pureFuncs = removeConsole.map((method) => `console.${method}`);
         options.compress = {
-          ...(0, import_shared34.isObject)(options.compress) ? options.compress : {},
+          ...(0, import_shared28.isObject)(options.compress) ? options.compress : {},
           pure_funcs: pureFuncs
         };
       }
@@ -4118,13 +4372,13 @@ var init_minimize = __esm({
       options.format.asciiOnly = config.output.charset === "ascii";
       const jsOptions = parseMinifyOptions(config).jsOptions;
       if (jsOptions) {
-        return (0, import_shared34.deepmerge)(options, jsOptions);
+        return (0, import_shared28.deepmerge)(options, jsOptions);
       }
       return options;
     };
-    parseMinifyOptions = (config, isProd6 = true) => {
+    parseMinifyOptions = (config, isProd7 = true) => {
       const minify = config.output.minify;
-      if (minify === false || !isProd6) {
+      if (minify === false || !isProd7) {
         return {
           minifyJs: false,
           minifyCss: false,
@@ -4156,19 +4410,19 @@ var init_minimize = __esm({
         if (api.context.bundlerType === "webpack") {
           return;
         }
-        api.modifyBundlerChain(async (chain, { isProd: isProd6 }) => {
+        api.modifyBundlerChain(async (chain, { isProd: isProd7 }) => {
           const config = api.getNormalizedConfig();
-          const isMinimize = isProd6 && config.output.minify !== false;
+          const isMinimize = isProd7 && config.output.minify !== false;
           if (!isMinimize) {
             return;
           }
           const { SwcJsMinimizerRspackPlugin, SwcCssMinimizerRspackPlugin } = import_core6.rspack;
           const { minifyJs, minifyCss } = parseMinifyOptions(config);
           if (minifyJs) {
-            chain.optimization.minimizer(import_shared34.CHAIN_ID.MINIMIZER.JS).use(SwcJsMinimizerRspackPlugin, [getSwcMinimizerOptions(config)]).end();
+            chain.optimization.minimizer(import_shared28.CHAIN_ID.MINIMIZER.JS).use(SwcJsMinimizerRspackPlugin, [getSwcMinimizerOptions(config)]).end();
           }
           if (minifyCss) {
-            chain.optimization.minimizer(import_shared34.CHAIN_ID.MINIMIZER.CSS).use(SwcCssMinimizerRspackPlugin, []).end();
+            chain.optimization.minimizer(import_shared28.CHAIN_ID.MINIMIZER.CSS).use(SwcCssMinimizerRspackPlugin, []).end();
           }
         });
       }
@@ -4185,11 +4439,11 @@ __export(HtmlBasicPlugin_exports, {
   VOID_TAGS: () => VOID_TAGS,
   hasTitle: () => hasTitle
 });
-var import_shared35, VOID_TAGS, HEAD_TAGS, FILE_ATTRS, hasTitle, getTagPriority, formatBasicTag, fromBasicTag, formatTags, applyTagConfig, addTitleTag, addFavicon, HtmlBasicPlugin;
+var import_shared29, VOID_TAGS, HEAD_TAGS, FILE_ATTRS, hasTitle, getTagPriority, formatBasicTag, fromBasicTag, formatTags, applyTagConfig, addTitleTag, addFavicon, HtmlBasicPlugin;
 var init_HtmlBasicPlugin = __esm({
   "src/rspack/HtmlBasicPlugin.ts"() {
     "use strict";
-    import_shared35 = require("@rsbuild/shared");
+    import_shared29 = require("@rsbuild/shared");
     init_helpers();
     init_pluginHelper();
     VOID_TAGS = [
@@ -4301,7 +4555,7 @@ var init_HtmlBasicPlugin = __esm({
         publicPath: data.publicPath
       };
       for (const item of tagConfig.tags) {
-        if ((0, import_shared35.isFunction)(item)) {
+        if ((0, import_shared29.isFunction)(item)) {
           tags = item(tags, utils) || tags;
         } else {
           tags.push(item);
@@ -4310,7 +4564,7 @@ var init_HtmlBasicPlugin = __esm({
           (tag1, tag2) => getTagPriority(tag1, tagConfig) - getTagPriority(tag2, tagConfig)
         );
       }
-      const [headTags, bodyTags] = (0, import_shared35.partition)(
+      const [headTags, bodyTags] = partition(
         tags,
         (tag) => tag.head ?? HEAD_TAGS.includes(tag.tag)
       );
@@ -4392,13 +4646,13 @@ var HtmlAppIconPlugin_exports = {};
 __export(HtmlAppIconPlugin_exports, {
   HtmlAppIconPlugin: () => HtmlAppIconPlugin
 });
-var import_node_fs4, import_node_path18, import_shared36, HtmlAppIconPlugin;
+var import_node_fs4, import_node_path18, import_shared30, HtmlAppIconPlugin;
 var init_HtmlAppIconPlugin = __esm({
   "src/rspack/HtmlAppIconPlugin.ts"() {
     "use strict";
     import_node_fs4 = __toESM(require("fs"));
     import_node_path18 = require("path");
-    import_shared36 = require("@rsbuild/shared");
+    import_shared30 = require("@rsbuild/shared");
     init_helpers();
     init_pluginHelper();
     HtmlAppIconPlugin = class {
@@ -4419,7 +4673,7 @@ var init_HtmlAppIconPlugin = __esm({
         const iconRelativePath = import_node_path18.posix.join(this.distDir, (0, import_node_path18.basename)(this.iconPath));
         compiler.hooks.compilation.tap(this.name, (compilation) => {
           getHTMLPlugin().getHooks(compilation).alterAssetTagGroups.tap(this.name, (data) => {
-            const publicPath = (0, import_shared36.getPublicPathFromCompiler)(compiler);
+            const publicPath = (0, import_shared30.getPublicPathFromCompiler)(compiler);
             data.headTags.unshift({
               tagName: "link",
               voidTag: true,
@@ -4499,8 +4753,8 @@ function getTerserMinifyOptions(config) {
   const finalOptions = applyRemoveConsole(options, config);
   return finalOptions;
 }
-async function getHtmlMinifyOptions(isProd6, config) {
-  if (!isProd6 || !config.output.minify || !parseMinifyOptions(config).minifyHtml) {
+async function getHtmlMinifyOptions(isProd7, config) {
+  if (!isProd7 || !config.output.minify || !parseMinifyOptions(config).minifyHtml) {
     return false;
   }
   const minifyJS = getTerserMinifyOptions(config);
@@ -4518,17 +4772,17 @@ async function getHtmlMinifyOptions(isProd6, config) {
     minifyURLs: true
   };
   const htmlMinifyOptions = parseMinifyOptions(config).htmlOptions;
-  return typeof htmlMinifyOptions === "object" ? (0, import_shared37.deepmerge)(htmlMinifyDefaultOptions, htmlMinifyOptions) : htmlMinifyDefaultOptions;
+  return typeof htmlMinifyOptions === "object" ? (0, import_shared31.deepmerge)(htmlMinifyDefaultOptions, htmlMinifyOptions) : htmlMinifyDefaultOptions;
 }
 function getTitle(entryName, config) {
-  return (0, import_shared37.reduceConfigsMergeContext)({
+  return (0, import_shared31.reduceConfigsMergeContext)({
     initial: "",
     config: config.html.title,
     ctx: { entryName }
   });
 }
 function getInject(entryName, config) {
-  return (0, import_shared37.reduceConfigsMergeContext)({
+  return (0, import_shared31.reduceConfigsMergeContext)({
     initial: "head",
     config: config.html.inject,
     ctx: { entryName }
@@ -4536,7 +4790,7 @@ function getInject(entryName, config) {
 }
 async function getTemplate(entryName, config, rootPath) {
   const DEFAULT_TEMPLATE = import_node_path19.default.resolve(STATIC_PATH, "template.html");
-  const templatePath = (0, import_shared37.reduceConfigsMergeContext)({
+  const templatePath = (0, import_shared31.reduceConfigsMergeContext)({
     initial: DEFAULT_TEMPLATE,
     config: config.html.template,
     ctx: { entryName }
@@ -4550,28 +4804,28 @@ async function getTemplate(entryName, config, rootPath) {
   if (!existTemplatePath.includes(absolutePath)) {
     if (!await isFileExists(absolutePath)) {
       throw new Error(
-        `Failed to resolve HTML template, please check if the file exists: ${import_shared37.color.cyan(
+        `Failed to resolve HTML template, please check if the file exists: ${import_shared31.color.cyan(
           absolutePath
         )}`
       );
     }
     existTemplatePath.push(absolutePath);
   }
-  const templateContent = await import_shared37.fse.readFile(absolutePath, "utf-8");
+  const templateContent = await import_shared31.fse.readFile(absolutePath, "utf-8");
   return {
     templatePath: absolutePath,
     templateContent
   };
 }
 function getFavicon(entryName, config) {
-  return (0, import_shared37.reduceConfigsMergeContext)({
+  return (0, import_shared31.reduceConfigsMergeContext)({
     initial: "",
     config: config.html.favicon,
     ctx: { entryName }
   });
 }
 function getMetaTags(entryName, config, templateContent) {
-  const metaTags = (0, import_shared37.reduceConfigsMergeContext)({
+  const metaTags = (0, import_shared31.reduceConfigsMergeContext)({
     initial: {},
     config: config.html.meta,
     ctx: { entryName }
@@ -4599,7 +4853,7 @@ function getTemplateParameters(entryName, config, assetPrefix) {
         options: pluginOptions
       }
     };
-    return (0, import_shared37.reduceConfigsWithContext)({
+    return (0, import_shared31.reduceConfigsWithContext)({
       initial: defaultOptions2,
       config: templateParameters,
       ctx: { entryName }
@@ -4609,7 +4863,7 @@ function getTemplateParameters(entryName, config, assetPrefix) {
 function getChunks(entryName, entryValue) {
   const chunks = [entryName];
   for (const item of entryValue) {
-    if (!(0, import_shared37.isPlainObject)(item)) {
+    if (!(0, import_shared31.isPlainObject)(item)) {
       continue;
     }
     const { dependOn } = item;
@@ -4624,19 +4878,19 @@ function getChunks(entryName, entryValue) {
   }
   return chunks;
 }
-var import_node_path19, import_shared37, existTemplatePath, getTagConfig, pluginHtml;
+var import_node_path19, import_shared31, existTemplatePath, getTagConfig, pluginHtml;
 var init_html = __esm({
   "src/plugins/html.ts"() {
     "use strict";
     import_node_path19 = __toESM(require("path"));
-    import_shared37 = require("@rsbuild/shared");
+    import_shared31 = require("@rsbuild/shared");
     init_constants();
     init_helpers();
     init_minimize();
     existTemplatePath = [];
     getTagConfig = (api) => {
       const config = api.getNormalizedConfig();
-      const tags = (0, import_shared37.castArray)(config.html.tags).filter(Boolean);
+      const tags = (0, import_shared31.castArray)(config.html.tags).filter(Boolean);
       if (!tags.length) {
         return void 0;
       }
@@ -4651,12 +4905,12 @@ var init_html = __esm({
       name: "rsbuild:html",
       setup(api) {
         api.modifyBundlerChain(
-          async (chain, { HtmlPlugin, isProd: isProd6, CHAIN_ID: CHAIN_ID3, target }) => {
+          async (chain, { HtmlPlugin, isProd: isProd7, CHAIN_ID: CHAIN_ID3, target }) => {
             const config = api.getNormalizedConfig();
-            if ((0, import_shared37.isHtmlDisabled)(config, target)) {
+            if ((0, import_shared31.isHtmlDisabled)(config, target)) {
               return;
             }
-            const minify = await getHtmlMinifyOptions(isProd6, config);
+            const minify = await getHtmlMinifyOptions(isProd7, config);
             const assetPrefix = getPublicPathFromChain(chain, false);
             const entries = chain.entryPoints.entries() || {};
             const entryNames = Object.keys(entries);
@@ -4705,13 +4959,13 @@ var init_html = __esm({
                 pluginOptions.title = getTitle(entryName, config);
                 const favicon = getFavicon(entryName, config);
                 if (favicon) {
-                  if ((0, import_shared37.isURL)(favicon)) {
+                  if (isURL(favicon)) {
                     htmlInfo.favicon = favicon;
                   } else {
                     pluginOptions.favicon = favicon;
                   }
                 }
-                const finalOptions2 = (0, import_shared37.reduceConfigsWithContext)({
+                const finalOptions2 = (0, import_shared31.reduceConfigsWithContext)({
                   initial: pluginOptions,
                   config: typeof config.tools.htmlPlugin === "boolean" ? {} : config.tools.htmlPlugin,
                   ctx: { entryName, entryValue }
@@ -4732,7 +4986,7 @@ var init_html = __esm({
               }
               if (appIcon) {
                 const { HtmlAppIconPlugin: HtmlAppIconPlugin2 } = await Promise.resolve().then(() => (init_HtmlAppIconPlugin(), HtmlAppIconPlugin_exports));
-                const distDir = (0, import_shared37.getDistPath)(config, "image");
+                const distDir = config.output.distPath.image;
                 const iconPath = import_node_path19.default.isAbsolute(appIcon) ? appIcon : import_node_path19.default.join(api.context.rootPath, appIcon);
                 chain.plugin(CHAIN_ID3.PLUGIN.APP_ICON).use(HtmlAppIconPlugin2, [{ iconPath, distDir }]);
               }
@@ -4767,18 +5021,17 @@ var wasm_exports = {};
 __export(wasm_exports, {
   pluginWasm: () => pluginWasm
 });
-var import_node_path20, import_shared38, pluginWasm;
+var import_node_path20, pluginWasm;
 var init_wasm = __esm({
   "src/plugins/wasm.ts"() {
     "use strict";
     import_node_path20 = require("path");
-    import_shared38 = require("@rsbuild/shared");
     pluginWasm = () => ({
       name: "rsbuild:wasm",
       setup(api) {
         api.modifyBundlerChain(async (chain, { CHAIN_ID: CHAIN_ID3 }) => {
           const config = api.getNormalizedConfig();
-          const distPath = (0, import_shared38.getDistPath)(config, "wasm");
+          const distPath = config.output.distPath.wasm;
           chain.experiments({
             ...chain.get("experiments"),
             asyncWebAssembly: true
@@ -4831,12 +5084,12 @@ var nodeAddons_exports = {};
 __export(nodeAddons_exports, {
   pluginNodeAddons: () => pluginNodeAddons
 });
-var import_node_path21, getFilename3, pluginNodeAddons;
+var import_node_path21, getFilename2, pluginNodeAddons;
 var init_nodeAddons = __esm({
   "src/plugins/nodeAddons.ts"() {
     "use strict";
     import_node_path21 = __toESM(require("path"));
-    getFilename3 = (resourcePath) => {
+    getFilename2 = (resourcePath) => {
       let basename2 = "";
       if (resourcePath) {
         const parsed = import_node_path21.default.parse(resourcePath);
@@ -4855,7 +5108,7 @@ var init_nodeAddons = __esm({
         api.transform(
           { test: /\.node$/, targets: ["node"], raw: true },
           ({ code, emitFile, resourcePath }) => {
-            const name = getFilename3(resourcePath);
+            const name = getFilename2(resourcePath);
             if (name === null) {
               throw new Error(`Failed to load Node.js addon: "${resourcePath}"`);
             }
@@ -4880,11 +5133,11 @@ var define_exports = {};
 __export(define_exports, {
   pluginDefine: () => pluginDefine
 });
-var import_shared39, pluginDefine;
+var import_shared32, pluginDefine;
 var init_define = __esm({
   "src/plugins/define.ts"() {
     "use strict";
-    import_shared39 = require("@rsbuild/shared");
+    import_shared32 = require("@rsbuild/shared");
     init_helpers();
     pluginDefine = () => ({
       name: "rsbuild:define",
@@ -4892,7 +5145,7 @@ var init_define = __esm({
         api.modifyBundlerChain((chain, { CHAIN_ID: CHAIN_ID3, bundler }) => {
           const config = api.getNormalizedConfig();
           const builtinVars = {
-            "process.env.NODE_ENV": JSON.stringify((0, import_shared39.getNodeEnv)()),
+            "process.env.NODE_ENV": JSON.stringify((0, import_shared32.getNodeEnv)()),
             "process.env.ASSET_PREFIX": JSON.stringify(
               getPublicPathFromChain(chain, false)
             )
@@ -4911,12 +5164,13 @@ var progress_exports = {};
 __export(progress_exports, {
   pluginProgress: () => pluginProgress
 });
-var import_shared40, import_core7, pluginProgress;
+var import_shared33, import_core7, pluginProgress;
 var init_progress = __esm({
   "src/plugins/progress.ts"() {
     "use strict";
-    import_shared40 = require("@rsbuild/shared");
+    import_shared33 = require("@rsbuild/shared");
     import_core7 = require("@rspack/core");
+    init_constants();
     pluginProgress = () => ({
       name: "rsbuild:progress",
       setup(api) {
@@ -4926,11 +5180,11 @@ var init_progress = __esm({
         api.modifyBundlerChain(async (chain, { target, CHAIN_ID: CHAIN_ID3 }) => {
           const config = api.getNormalizedConfig();
           const options = config.dev.progressBar ?? // enable progress bar in production by default
-          (0, import_shared40.isProd)();
+          (0, import_shared33.isProd)();
           if (!options) {
             return;
           }
-          const prefix = options !== true && options.id !== void 0 ? options.id : import_shared40.TARGET_ID_MAP[target];
+          const prefix = options !== true && options.id !== void 0 ? options.id : TARGET_ID_MAP[target];
           chain.plugin(CHAIN_ID3.PLUGIN.PROGRESS).use(import_core7.rspack.ProgressPlugin, [
             {
               prefix,
@@ -4964,13 +5218,13 @@ async function getDefaultSwcConfig(config, rootPath, target) {
     },
     isModule: "unknown",
     env: {
-      targets: await (0, import_shared41.getBrowserslistWithDefault)(rootPath, config, target)
+      targets: await (0, import_shared34.getBrowserslistWithDefault)(rootPath, config, target)
     }
   };
 }
 async function applyCoreJs(swcConfig, polyfillMode) {
   const coreJsPath = require.resolve("core-js/package.json");
-  const version2 = (0, import_shared41.getCoreJsVersion)(coreJsPath);
+  const version2 = (0, import_shared34.getCoreJsVersion)(coreJsPath);
   const coreJsDir = import_node_path22.default.dirname(coreJsPath);
   swcConfig.env.coreJs = version2;
   if (polyfillMode === "usage") {
@@ -5003,13 +5257,14 @@ function applySwcDecoratorConfig(swcConfig, config) {
       throw new Error("Unknown decorators version: ${version}");
   }
 }
-var import_node_path22, import_shared41, builtinSwcLoaderName, pluginSwc;
+var import_node_path22, import_shared34, builtinSwcLoaderName, pluginSwc;
 var init_swc = __esm({
   "src/plugins/swc.ts"() {
     "use strict";
     import_node_path22 = __toESM(require("path"));
-    import_shared41 = require("@rsbuild/shared");
+    import_shared34 = require("@rsbuild/shared");
     init_constants();
+    init_helpers();
     builtinSwcLoaderName = "builtin:swc-loader";
     pluginSwc = () => ({
       name: PLUGIN_SWC_NAME,
@@ -5021,11 +5276,11 @@ var init_swc = __esm({
           order: "pre",
           handler: async (chain, { CHAIN_ID: CHAIN_ID3, target }) => {
             const config = api.getNormalizedConfig();
-            const rule = chain.module.rule(CHAIN_ID3.RULE.JS).test(import_shared41.SCRIPT_REGEX).type("javascript/auto");
+            const rule = chain.module.rule(CHAIN_ID3.RULE.JS).test(import_shared34.SCRIPT_REGEX).type("javascript/auto");
             const dataUriRule = chain.module.rule(CHAIN_ID3.RULE.JS_DATA_URI).mimetype({
               or: ["text/javascript", "application/javascript"]
             });
-            (0, import_shared41.applyScriptCondition)({
+            (0, import_shared34.applyScriptCondition)({
               rule,
               chain,
               config,
@@ -5046,7 +5301,7 @@ var init_swc = __esm({
                 import_node_path22.default.dirname(require.resolve("@swc/helpers/package.json"))
               );
             }
-            if ((0, import_shared41.isWebTarget)(target)) {
+            if (isWebTarget(target)) {
               const polyfillMode = config.output.polyfill;
               if (polyfillMode === "off") {
                 swcConfig.env.mode = void 0;
@@ -5058,13 +5313,13 @@ var init_swc = __esm({
                 }
               }
             }
-            const mergedSwcConfig = (0, import_shared41.reduceConfigs)({
+            const mergedSwcConfig = (0, import_shared34.reduceConfigs)({
               initial: swcConfig,
               config: config.tools.swc,
-              mergeFn: import_shared41.deepmerge
+              mergeFn: import_shared34.deepmerge
             });
             rule.use(CHAIN_ID3.USE.SWC).loader(builtinSwcLoaderName).options(mergedSwcConfig);
-            dataUriRule.resolve.set("fullySpecified", false).end().use(CHAIN_ID3.USE.SWC).loader(builtinSwcLoaderName).options((0, import_shared41.cloneDeep)(mergedSwcConfig));
+            dataUriRule.resolve.set("fullySpecified", false).end().use(CHAIN_ID3.USE.SWC).loader(builtinSwcLoaderName).options((0, import_shared34.cloneDeep)(mergedSwcConfig));
           }
         });
       }
@@ -5131,11 +5386,11 @@ function splitByExperience(ctx) {
   const { override, polyfill, defaultConfig, userDefinedCacheGroups } = ctx;
   const experienceCacheGroup = {};
   const packageRegExps = {
-    lodash: (0, import_shared42.createDependenciesRegExp)("lodash", "lodash-es"),
-    axios: (0, import_shared42.createDependenciesRegExp)("axios", /axios-.+/)
+    lodash: (0, import_shared35.createDependenciesRegExp)("lodash", "lodash-es"),
+    axios: (0, import_shared35.createDependenciesRegExp)("axios", /axios-.+/)
   };
   if (polyfill === "entry" || polyfill === "usage") {
-    packageRegExps.polyfill = (0, import_shared42.createDependenciesRegExp)(
+    packageRegExps.polyfill = (0, import_shared35.createDependenciesRegExp)(
       "tslib",
       "core-js",
       "@babel/runtime",
@@ -5184,7 +5439,7 @@ function splitByModule(ctx) {
       // Core group
       vendors: {
         priority: -9,
-        test: import_shared42.NODE_MODULES_REGEX,
+        test: import_shared35.NODE_MODULES_REGEX,
         name(module2) {
           return module2 ? getPackageNameFromModulePath(module2.context) : void 0;
         }
@@ -5227,7 +5482,7 @@ function singleVendor(ctx) {
   const { override, defaultConfig, userDefinedCacheGroups } = ctx;
   const singleVendorCacheGroup = {
     singleVendor: {
-      test: import_shared42.NODE_MODULES_REGEX,
+      test: import_shared35.NODE_MODULES_REGEX,
       priority: 0,
       chunks: "all",
       name: "vendor",
@@ -5246,12 +5501,12 @@ function singleVendor(ctx) {
     }
   };
 }
-var import_node_assert, import_shared42, MODULE_PATH_REGEX, SPLIT_STRATEGY_DISPATCHER, pluginSplitChunks;
+var import_node_assert, import_shared35, MODULE_PATH_REGEX, SPLIT_STRATEGY_DISPATCHER, pluginSplitChunks;
 var init_splitChunks = __esm({
   "src/plugins/splitChunks.ts"() {
     "use strict";
     import_node_assert = __toESM(require("assert"));
-    import_shared42 = require("@rsbuild/shared");
+    import_shared35 = require("@rsbuild/shared");
     MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\/])?([^\\/]+)/;
     SPLIT_STRATEGY_DISPATCHER = {
       "split-by-experience": splitByExperience,
@@ -5334,10 +5589,10 @@ async function openBrowser(url2) {
         );
         return true;
       }
-      (0, import_shared43.debug)("Failed to find the target browser.");
+      import_rslog.logger.debug("Failed to find the target browser.");
     } catch (err) {
-      (0, import_shared43.debug)("Failed to open start URL with apple script.");
-      import_shared43.logger.debug(err);
+      import_rslog.logger.debug("Failed to open start URL with apple script.");
+      import_rslog.logger.debug(err);
     }
   }
   try {
@@ -5345,8 +5600,8 @@ async function openBrowser(url2) {
     await open(url2);
     return true;
   } catch (err) {
-    import_shared43.logger.error("Failed to open start URL.");
-    import_shared43.logger.error(err);
+    import_rslog.logger.error("Failed to open start URL.");
+    import_rslog.logger.error(err);
     return false;
   }
 }
@@ -5409,15 +5664,16 @@ function pluginOpen() {
     }
   };
 }
-var import_node_child_process, import_node_util, import_shared43, execAsync, supportedChromiumBrowsers, getTargetBrowser, replacePlaceholder, openedURLs, normalizeOpenConfig;
+var import_node_child_process, import_node_util, import_shared36, execAsync, supportedChromiumBrowsers, getTargetBrowser, replacePlaceholder, openedURLs, normalizeOpenConfig;
 var init_open = __esm({
   "src/plugins/open.ts"() {
     "use strict";
     import_node_child_process = require("child_process");
     import_node_util = require("util");
-    import_shared43 = require("@rsbuild/shared");
+    import_shared36 = require("@rsbuild/shared");
     init_constants();
     init_helpers();
+    init_logger();
     execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
     supportedChromiumBrowsers = [
       "Google Chrome Canary",
@@ -5455,7 +5711,7 @@ var init_open = __esm({
         return { targets: open, before: beforeStartUrl };
       }
       return {
-        targets: open.target ? (0, import_shared43.castArray)(open.target) : [],
+        targets: open.target ? (0, import_shared36.castArray)(open.target) : [],
         before: open.before
       };
     };
@@ -5467,12 +5723,13 @@ var InlineChunkHtmlPlugin_exports = {};
 __export(InlineChunkHtmlPlugin_exports, {
   InlineChunkHtmlPlugin: () => InlineChunkHtmlPlugin
 });
-var import_node_path23, import_shared44, InlineChunkHtmlPlugin;
+var import_node_path23, import_shared37, InlineChunkHtmlPlugin;
 var init_InlineChunkHtmlPlugin = __esm({
   "src/rspack/InlineChunkHtmlPlugin.ts"() {
     "use strict";
     import_node_path23 = require("path");
-    import_shared44 = require("@rsbuild/shared");
+    import_shared37 = require("@rsbuild/shared");
+    init_helpers();
     init_pluginHelper();
     InlineChunkHtmlPlugin = class {
       constructor({
@@ -5505,7 +5762,7 @@ var init_InlineChunkHtmlPlugin = __esm({
         const { devtool } = compilation.options;
         if (devtool && // If the source map is inlined, we do not need to update the sourceMappingURL
         !devtool.includes("inline") && source.includes("# sourceMappingURL")) {
-          const prefix = (0, import_shared44.addTrailingSlash)(
+          const prefix = addTrailingSlash(
             (0, import_node_path23.join)(publicPath, this.distPath[type] || "")
           );
           return source.replace(
@@ -5517,7 +5774,7 @@ var init_InlineChunkHtmlPlugin = __esm({
       }
       matchTests(name, source, tests) {
         return tests.some((test) => {
-          if ((0, import_shared44.isFunction)(test)) {
+          if ((0, import_shared37.isFunction)(test)) {
             const size = source.length;
             return test({ name, size });
           }
@@ -5603,7 +5860,7 @@ var init_InlineChunkHtmlPlugin = __esm({
       }
       apply(compiler) {
         compiler.hooks.compilation.tap(this.name, (compilation) => {
-          const publicPath = (0, import_shared44.getPublicPathFromCompiler)(compiler);
+          const publicPath = (0, import_shared37.getPublicPathFromCompiler)(compiler);
           const tagFunction = (tag) => this.getInlinedTag(publicPath, tag, compilation);
           const hooks = getHTMLPlugin().getHooks(compilation);
           hooks.alterAssetTagGroups.tap(this.name, (assets) => {
@@ -5643,18 +5900,19 @@ var inlineChunk_exports = {};
 __export(inlineChunk_exports, {
   pluginInlineChunk: () => pluginInlineChunk
 });
-var import_shared45, pluginInlineChunk;
+var import_shared38, pluginInlineChunk;
 var init_inlineChunk = __esm({
   "src/plugins/inlineChunk.ts"() {
     "use strict";
-    import_shared45 = require("@rsbuild/shared");
+    import_shared38 = require("@rsbuild/shared");
     init_constants();
+    init_helpers();
     pluginInlineChunk = () => ({
       name: "rsbuild:inline-chunk",
       setup(api) {
         api.modifyBundlerChain(async (chain, { target, CHAIN_ID: CHAIN_ID3, isDev: isDev3 }) => {
           const config = api.getNormalizedConfig();
-          if ((0, import_shared45.isHtmlDisabled)(config, target) || isDev3) {
+          if ((0, import_shared38.isHtmlDisabled)(config, target) || isDev3) {
             return;
           }
           const { InlineChunkHtmlPlugin: InlineChunkHtmlPlugin2 } = await Promise.resolve().then(() => (init_InlineChunkHtmlPlugin(), InlineChunkHtmlPlugin_exports));
@@ -5662,7 +5920,7 @@ var init_inlineChunk = __esm({
           const scriptTests = [];
           const styleTests = [];
           if (inlineScripts) {
-            scriptTests.push(inlineScripts === true ? import_shared45.JS_REGEX : inlineScripts);
+            scriptTests.push(inlineScripts === true ? import_shared38.JS_REGEX : inlineScripts);
           }
           if (inlineStyles) {
             styleTests.push(inlineStyles === true ? CSS_REGEX : inlineStyles);
@@ -5674,7 +5932,7 @@ var init_inlineChunk = __esm({
             {
               styleTests,
               scriptTests,
-              distPath: (0, import_shared45.pick)(config.output.distPath, ["js", "css"])
+              distPath: pick(config.output.distPath, ["js", "css"])
             }
           ]);
         });
@@ -5693,7 +5951,7 @@ function pluginBundleAnalyzer() {
     name: "rsbuild:bundle-analyzer",
     setup(api) {
       api.modifyRsbuildConfig((config) => {
-        if ((0, import_shared46.isProd)() || !isUseAnalyzer(config)) {
+        if ((0, import_shared39.isProd)() || !isUseAnalyzer(config)) {
           return;
         }
         config.dev ||= {};
@@ -5718,11 +5976,11 @@ function pluginBundleAnalyzer() {
     }
   };
 }
-var import_shared46, isUseAnalyzer;
+var import_shared39, isUseAnalyzer;
 var init_bundleAnalyzer = __esm({
   "src/plugins/bundleAnalyzer.ts"() {
     "use strict";
-    import_shared46 = require("@rsbuild/shared");
+    import_shared39 = require("@rsbuild/shared");
     isUseAnalyzer = (config) => process.env.BUNDLE_ANALYZE || config.performance?.bundleAnalyze;
   }
 });
@@ -5732,11 +5990,12 @@ var rsdoctor_exports = {};
 __export(rsdoctor_exports, {
   pluginRsdoctor: () => pluginRsdoctor
 });
-var import_shared47, pluginRsdoctor;
+var import_shared40, pluginRsdoctor;
 var init_rsdoctor = __esm({
   "src/plugins/rsdoctor.ts"() {
     "use strict";
-    import_shared47 = require("@rsbuild/shared");
+    import_shared40 = require("@rsbuild/shared");
+    init_logger();
     pluginRsdoctor = () => ({
       name: "rsbuild:rsdoctor",
       setup(api) {
@@ -5753,8 +6012,8 @@ var init_rsdoctor = __esm({
             });
             module2 = await import(path13);
           } catch (err) {
-            import_shared47.logger.warn(
-              `\`process.env.RSDOCTOR\` enabled, please install ${import_shared47.color.bold(import_shared47.color.yellow(packageName))} package.`
+            import_rslog.logger.warn(
+              `\`process.env.RSDOCTOR\` enabled, please install ${import_shared40.color.bold(import_shared40.color.yellow(packageName))} package.`
             );
             return;
           }
@@ -5775,7 +6034,7 @@ var init_rsdoctor = __esm({
             isAutoRegister = true;
           }
           if (isAutoRegister) {
-            import_shared47.logger.info(`${import_shared47.color.bold(import_shared47.color.yellow(packageName))} enabled.`);
+            import_rslog.logger.info(`${import_shared40.color.bold(import_shared40.color.yellow(packageName))} enabled.`);
           }
         });
       }
@@ -5971,7 +6230,7 @@ function generateLinks(options, type, compilation, htmlPluginData, HTMLCount) {
   );
   const sortedFilteredFiles = filteredFiles.sort();
   const links = [];
-  const publicPath = (0, import_shared48.getPublicPathFromCompiler)(compilation.compiler);
+  const publicPath = (0, import_shared41.getPublicPathFromCompiler)(compilation.compiler);
   const { crossOriginLoading } = compilation.compiler.options.output;
   for (const file of sortedFilteredFiles) {
     const href = ensureAssetPrefix(file, publicPath);
@@ -6002,11 +6261,11 @@ function generateLinks(options, type, compilation, htmlPluginData, HTMLCount) {
   }
   return links;
 }
-var import_shared48, defaultOptions, HtmlPreloadOrPrefetchPlugin;
+var import_shared41, defaultOptions, HtmlPreloadOrPrefetchPlugin;
 var init_HtmlPreloadOrPrefetchPlugin = __esm({
   "src/rspack/preload/HtmlPreloadOrPrefetchPlugin.ts"() {
     "use strict";
-    import_shared48 = require("@rsbuild/shared");
+    import_shared41 = require("@rsbuild/shared");
     init_helpers();
     init_pluginHelper();
     init_helpers2();
@@ -6029,7 +6288,7 @@ var init_HtmlPreloadOrPrefetchPlugin = __esm({
       apply(compiler) {
         compiler.hooks.compilation.tap(this.constructor.name, (compilation) => {
           getHTMLPlugin().getHooks(compilation).beforeAssetTagGeneration.tap(
-            `HTML${(0, import_shared48.upperFirst)(this.type)}Plugin`,
+            `HTML${upperFirst(this.type)}Plugin`,
             (htmlPluginData) => {
               this.resourceHints = generateLinks(
                 this.options,
@@ -6042,7 +6301,7 @@ var init_HtmlPreloadOrPrefetchPlugin = __esm({
             }
           );
           getHTMLPlugin().getHooks(compilation).alterAssetTags.tap(
-            `HTML${(0, import_shared48.upperFirst)(this.type)}Plugin`,
+            `HTML${upperFirst(this.type)}Plugin`,
             (htmlPluginData) => {
               if (this.resourceHints) {
                 htmlPluginData.assetTags.styles = [
@@ -6067,11 +6326,11 @@ var resourceHints_exports = {};
 __export(resourceHints_exports, {
   pluginResourceHints: () => pluginResourceHints
 });
-var import_shared49, generateLinks2, pluginResourceHints;
+var import_shared42, generateLinks2, pluginResourceHints;
 var init_resourceHints = __esm({
   "src/plugins/resourceHints.ts"() {
     "use strict";
-    import_shared49 = require("@rsbuild/shared");
+    import_shared42 = require("@rsbuild/shared");
     generateLinks2 = (options, rel) => options.map((option) => ({
       tag: "link",
       attrs: {
@@ -6106,7 +6365,7 @@ var init_resourceHints = __esm({
           const {
             performance: { preload, prefetch }
           } = config;
-          if ((0, import_shared49.isHtmlDisabled)(config, target)) {
+          if ((0, import_shared42.isHtmlDisabled)(config, target)) {
             return;
           }
           const HTMLCount = chain.entryPoints.values().length;
@@ -6169,12 +6428,12 @@ var server_exports = {};
 __export(server_exports, {
   pluginServer: () => pluginServer
 });
-var import_node_path25, import_shared50, pluginServer;
+var import_node_path25, import_shared43, pluginServer;
 var init_server = __esm({
   "src/plugins/server.ts"() {
     "use strict";
     import_node_path25 = require("path");
-    import_shared50 = require("@rsbuild/shared");
+    import_shared43 = require("@rsbuild/shared");
     init_config();
     pluginServer = () => ({
       name: "rsbuild:server",
@@ -6188,11 +6447,11 @@ var init_server = __esm({
               continue;
             }
             const normalizedPath = (0, import_node_path25.isAbsolute)(name) ? name : (0, import_node_path25.join)(api.context.rootPath, name);
-            if (!import_shared50.fse.existsSync(normalizedPath)) {
+            if (!import_shared43.fse.existsSync(normalizedPath)) {
               continue;
             }
             try {
-              await import_shared50.fse.copy(normalizedPath, api.context.distPath, {
+              await import_shared43.fse.copy(normalizedPath, api.context.distPath, {
                 // dereference symlinks
                 dereference: true
               });
@@ -6359,18 +6618,18 @@ function pluginModuleFederation() {
           chain.plugin("mf-patch-split-chunks").use(PatchSplitChunksPlugin, [options.name]);
         }
         const publicPath = chain.output.get("publicPath");
-        if (publicPath === import_shared51.DEFAULT_ASSET_PREFIX) {
+        if (publicPath === import_shared44.DEFAULT_ASSET_PREFIX) {
           chain.output.set("publicPath", "auto");
         }
       });
     }
   };
 }
-var import_shared51, import_core8, PatchSplitChunksPlugin;
+var import_shared44, import_core8, PatchSplitChunksPlugin;
 var init_moduleFederation = __esm({
   "src/plugins/moduleFederation.ts"() {
     "use strict";
-    import_shared51 = require("@rsbuild/shared");
+    import_shared44 = require("@rsbuild/shared");
     import_core8 = require("@rspack/core");
     PatchSplitChunksPlugin = class {
       constructor(name) {
@@ -6438,25 +6697,25 @@ __export(rspackProfile_exports, {
   pluginRspackProfile: () => pluginRspackProfile,
   stopProfiler: () => stopProfiler
 });
-var import_node_inspector, import_node_path26, import_shared52, import_shared53, import_core9, stopProfiler, pluginRspackProfile;
+var import_node_inspector, import_node_path26, import_shared45, import_core9, stopProfiler, pluginRspackProfile;
 var init_rspackProfile = __esm({
   "src/plugins/rspackProfile.ts"() {
     "use strict";
     import_node_inspector = __toESM(require("inspector"));
     import_node_path26 = __toESM(require("path"));
-    import_shared52 = require("@rsbuild/shared");
-    import_shared53 = require("@rsbuild/shared");
+    import_shared45 = require("@rsbuild/shared");
     import_core9 = require("@rspack/core");
+    init_logger();
     stopProfiler = (output, profileSession) => {
       if (!profileSession) {
         return;
       }
       profileSession.post("Profiler.stop", (error, param) => {
         if (error) {
-          import_shared53.logger.error("Failed to generate JS CPU profile:", error);
+          import_rslog.logger.error("Failed to generate JS CPU profile:", error);
           return;
         }
-        import_shared52.fse.writeFileSync(output, JSON.stringify(param.profile));
+        import_shared45.fse.writeFileSync(output, JSON.stringify(param.profile));
       });
     };
     pluginRspackProfile = () => ({
@@ -6482,7 +6741,7 @@ var init_rspackProfile = __esm({
         const cpuProfilePath = import_node_path26.default.join(profileDir, "jscpuprofile.json");
         const loggingFilePath = import_node_path26.default.join(profileDir, "logging.json");
         const onStart = () => {
-          import_shared52.fse.ensureDirSync(profileDir);
+          import_shared45.fse.ensureDirSync(profileDir);
           if (enableProfileTrace) {
             import_core9.rspack.experimental_registerGlobalTrace(
               "trace",
@@ -6506,7 +6765,7 @@ var init_rspackProfile = __esm({
               logging: "verbose",
               loggingTrace: true
             });
-            import_shared52.fse.writeFileSync(loggingFilePath, JSON.stringify(logging));
+            import_shared45.fse.writeFileSync(loggingFilePath, JSON.stringify(logging));
           }
         });
         api.onExit(() => {
@@ -6514,7 +6773,7 @@ var init_rspackProfile = __esm({
             import_core9.rspack.experimental_cleanupGlobalTrace();
           }
           stopProfiler(cpuProfilePath, profileSession);
-          import_shared53.logger.info(`Saved Rspack profile file to ${profileDir}`);
+          import_rslog.logger.info(`Saved Rspack profile file to ${profileDir}`);
         });
       }
     });
@@ -6526,16 +6785,16 @@ var lazyCompilation_exports = {};
 __export(lazyCompilation_exports, {
   pluginLazyCompilation: () => pluginLazyCompilation
 });
-var import_shared54, pluginLazyCompilation;
+var pluginLazyCompilation;
 var init_lazyCompilation = __esm({
   "src/plugins/lazyCompilation.ts"() {
     "use strict";
-    import_shared54 = require("@rsbuild/shared");
+    init_helpers();
     pluginLazyCompilation = () => ({
       name: "rsbuild:lazy-compilation",
       setup(api) {
-        api.modifyBundlerChain((chain, { isProd: isProd6, target }) => {
-          if (isProd6 || target !== "web") {
+        api.modifyBundlerChain((chain, { isProd: isProd7, target }) => {
+          if (isProd7 || target !== "web") {
             return;
           }
           const config = api.getNormalizedConfig();
@@ -6576,7 +6835,7 @@ var init_lazyCompilation = __esm({
                 if (!name || isExcludedModule(name)) {
                   return false;
                 }
-                if ((0, import_shared54.isRegExp)(test)) {
+                if (isRegExp(test)) {
                   return name ? test.test(name) : false;
                 }
                 return test(module2);
@@ -6598,18 +6857,20 @@ var sri_exports = {};
 __export(sri_exports, {
   pluginSri: () => pluginSri
 });
-var import_node_crypto2, import_shared55, getAssetName, pluginSri;
+var import_node_crypto2, import_shared46, getAssetName, pluginSri;
 var init_sri = __esm({
   "src/plugins/sri.ts"() {
     "use strict";
     import_node_crypto2 = __toESM(require("crypto"));
-    import_shared55 = require("@rsbuild/shared");
+    import_shared46 = require("@rsbuild/shared");
     init_constants();
+    init_helpers();
+    init_logger();
     getAssetName = (url2, assetPrefix) => {
       if (url2.startsWith(assetPrefix)) {
-        return (0, import_shared55.removeLeadingSlash)(url2.replace(assetPrefix, ""));
+        return removeLeadingSlash(url2.replace(assetPrefix, ""));
       }
-      return (0, import_shared55.removeLeadingSlash)(url2);
+      return removeLeadingSlash(url2);
     };
     pluginSri = () => ({
       name: "rsbuild:sri",
@@ -6618,7 +6879,7 @@ var init_sri = __esm({
         const getAlgorithm = () => {
           const config = api.getNormalizedConfig();
           const { sri } = config.security;
-          const enable = sri.enable === "auto" ? (0, import_shared55.isProd)() : sri.enable;
+          const enable = sri.enable === "auto" ? (0, import_shared46.isProd)() : sri.enable;
           if (!enable) {
             return null;
           }
@@ -6685,7 +6946,7 @@ var init_sri = __esm({
                 `integrity="${integrity}"`
               );
             } else {
-              import_shared55.logger.debug(
+              import_rslog.logger.debug(
                 `[rsbuild:sri] failed to generate integrity for ${assetName}.`
               );
               replacedHtml = replacedHtml.replace(
@@ -6738,7 +6999,7 @@ var init_sri = __esm({
         }
         api.modifyBundlerChain((chain, { target }) => {
           const config = api.getNormalizedConfig();
-          if ((0, import_shared55.isHtmlDisabled)(config, target)) {
+          if ((0, import_shared46.isHtmlDisabled)(config, target)) {
             return;
           }
           const algorithm = getAlgorithm();
@@ -6757,11 +7018,11 @@ var nonce_exports = {};
 __export(nonce_exports, {
   pluginNonce: () => pluginNonce
 });
-var import_shared56, pluginNonce;
+var pluginNonce;
 var init_nonce = __esm({
   "src/plugins/nonce.ts"() {
     "use strict";
-    import_shared56 = require("@rsbuild/shared");
+    init_helpers();
     pluginNonce = () => ({
       name: "rsbuild:nonce",
       setup(api) {
@@ -6770,7 +7031,7 @@ var init_nonce = __esm({
           if (!nonce) {
             return;
           }
-          (0, import_shared56.applyToCompiler)(compiler, (compiler2) => {
+          applyToCompiler(compiler, (compiler2) => {
             const { plugins } = compiler2.options;
             const hasHTML = plugins.some(
               (plugin) => plugin && plugin.constructor.name === "HtmlBasicPlugin"
@@ -6778,7 +7039,7 @@ var init_nonce = __esm({
             if (!hasHTML) {
               return;
             }
-            const injectCode = (0, import_shared56.createVirtualModule)(
+            const injectCode = createVirtualModule(
               `__webpack_nonce__ = "${nonce}";`
             );
             new compiler2.webpack.EntryPlugin(compiler2.context, injectCode, {
@@ -6816,8 +7077,8 @@ __export(prodServer_exports, {
   startProdServer: () => startProdServer
 });
 async function startProdServer(context, config, { getPortSilently } = {}) {
-  if (!(0, import_shared57.getNodeEnv)()) {
-    (0, import_shared57.setNodeEnv)("production");
+  if (!(0, import_shared47.getNodeEnv)()) {
+    (0, import_shared47.setNodeEnv)("production");
   }
   const { port, host, https } = await getServerConfig({
     config,
@@ -6885,13 +7146,14 @@ async function startProdServer(context, config, { getPortSilently } = {}) {
     );
   });
 }
-var import_node_path27, import_shared57, RsbuildProdServer;
+var import_node_path27, import_shared47, RsbuildProdServer;
 var init_prodServer = __esm({
   "src/server/prodServer.ts"() {
     "use strict";
     import_node_path27 = require("path");
-    import_shared57 = require("@rsbuild/shared");
+    import_shared47 = require("@rsbuild/shared");
     init_constants();
+    init_logger();
     init_helper();
     init_httpServer();
     init_middlewares();
@@ -6910,7 +7172,7 @@ var init_prodServer = __esm({
       }
       async applyDefaultMiddlewares() {
         const { headers, proxy, historyApiFallback, compress } = this.options.serverConfig;
-        if ((0, import_shared57.isDebug)()) {
+        if (import_rslog.logger.level === "verbose") {
           this.middlewares.use(await getRequestLoggerMiddleware());
         }
         if (compress) {
@@ -7076,9 +7338,9 @@ async function createRsbuild(options = {}) {
   );
   const pluginAPI = getPluginAPI({ context, pluginManager });
   context.pluginAPI = pluginAPI;
-  (0, import_shared58.debug)("add default plugins");
+  import_rslog.logger.debug("add default plugins");
   await applyDefaultPlugins(pluginManager, context);
-  (0, import_shared58.debug)("add default plugins done");
+  import_rslog.logger.debug("add default plugins done");
   const provider = rsbuildConfig.provider || await getRspackProvider();
   const providerInstance = await provider({
     context,
@@ -7092,13 +7354,13 @@ async function createRsbuild(options = {}) {
     return startProdServer2(context, config, options2);
   };
   const rsbuild = {
-    ...(0, import_shared58.pick)(pluginManager, [
+    ...pick(pluginManager, [
       "addPlugins",
       "getPlugins",
       "removePlugins",
       "isPluginExists"
     ]),
-    ...(0, import_shared58.pick)(pluginAPI, [
+    ...pick(pluginAPI, [
       "onBeforeBuild",
       "onBeforeCreateCompiler",
       "onBeforeStartDevServer",
@@ -7114,7 +7376,7 @@ async function createRsbuild(options = {}) {
       "getRsbuildConfig",
       "getNormalizedConfig"
     ]),
-    ...(0, import_shared58.pick)(providerInstance, [
+    ...pick(providerInstance, [
       "build",
       "initConfigs",
       "inspectConfig",
@@ -7131,14 +7393,15 @@ async function createRsbuild(options = {}) {
   }
   return rsbuild;
 }
-var import_shared58, getRspackProvider, pickRsbuildConfig;
+var getRspackProvider, pickRsbuildConfig;
 var init_createRsbuild = __esm({
   "src/createRsbuild.ts"() {
     "use strict";
-    import_shared58 = require("@rsbuild/shared");
     init_createContext();
+    init_helpers();
     init_initPlugins();
     init_internal();
+    init_logger();
     init_pluginHelper();
     init_pluginManager();
     getRspackProvider = async () => {
@@ -7156,9 +7419,10 @@ var init_createRsbuild = __esm({
         "security",
         "performance",
         "moduleFederation",
+        "environments",
         "_privateMeta"
       ];
-      return (0, import_shared58.pick)(rsbuildConfig, keys);
+      return pick(rsbuildConfig, keys);
     };
   }
 });
@@ -7177,7 +7441,7 @@ async function init({
       cwd: root,
       mode: cliOptions?.envMode
     });
-    if ((0, import_shared59.isDev)()) {
+    if ((0, import_shared48.isDev)()) {
       onBeforeRestartServer(envs.cleanup);
     }
     const { content: config, filePath: configFilePath } = await loadConfig({
@@ -7217,19 +7481,20 @@ async function init({
     });
   } catch (err) {
     if (isRestart) {
-      import_shared59.logger.error(err);
+      import_rslog.logger.error(err);
     } else {
       throw err;
     }
   }
 }
-var import_shared59, commonOpts;
+var import_shared48, commonOpts;
 var init_init = __esm({
   "src/cli/init.ts"() {
     "use strict";
-    import_shared59 = require("@rsbuild/shared");
+    import_shared48 = require("@rsbuild/shared");
     init_config();
     init_loadEnv();
+    init_logger();
     init_restart();
     commonOpts = {};
   }
@@ -7237,7 +7502,7 @@ var init_init = __esm({
 
 // src/cli/commands.ts
 function runCli() {
-  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.7.8");
+  import_commander.program.name("rsbuild").usage("<command> [options]").version("0.7.9");
   const devCommand = import_commander.program.command("dev");
   const buildCommand = import_commander.program.command("build");
   const previewCommand = import_commander.program.command("preview");
@@ -7251,8 +7516,8 @@ function runCli() {
       const rsbuild = await init({ cliOptions: options });
       await rsbuild?.startDevServer();
     } catch (err) {
-      import_shared60.logger.error("Failed to start dev server.");
-      import_shared60.logger.error(err);
+      import_rslog.logger.error("Failed to start dev server.");
+      import_rslog.logger.error(err);
       process.exit(1);
     }
   });
@@ -7263,8 +7528,8 @@ function runCli() {
         watch: options.watch
       });
     } catch (err) {
-      import_shared60.logger.error("Failed to build.");
-      import_shared60.logger.error(err);
+      import_rslog.logger.error("Failed to build.");
+      import_rslog.logger.error(err);
       process.exit(1);
     }
   });
@@ -7275,14 +7540,14 @@ function runCli() {
         const { distPath } = rsbuild.context;
         if (!(0, import_node_fs5.existsSync)(distPath)) {
           throw new Error(
-            `The output directory ${import_shared60.color.yellow(
+            `The output directory ${import_shared49.color.yellow(
               distPath
             )} does not exist, please build the project before previewing.`
           );
         }
         if (isEmptyDir(distPath)) {
           throw new Error(
-            `The output directory ${import_shared60.color.yellow(
+            `The output directory ${import_shared49.color.yellow(
               distPath
             )} is empty, please build the project before previewing.`
           );
@@ -7290,8 +7555,8 @@ function runCli() {
       }
       await rsbuild?.preview();
     } catch (err) {
-      import_shared60.logger.error("Failed to start preview server.");
-      import_shared60.logger.error(err);
+      import_rslog.logger.error("Failed to start preview server.");
+      import_rslog.logger.error(err);
       process.exit(1);
     }
   });
@@ -7305,22 +7570,23 @@ function runCli() {
         writeToDisk: true
       });
     } catch (err) {
-      import_shared60.logger.error("Failed to inspect config.");
-      import_shared60.logger.error(err);
+      import_rslog.logger.error("Failed to inspect config.");
+      import_rslog.logger.error(err);
       process.exit(1);
     }
   });
   import_commander.program.parse();
 }
-var import_node_fs5, import_node_path28, import_shared60, import_commander, applyCommonOptions, applyServerOptions;
+var import_node_fs5, import_node_path28, import_shared49, import_commander, applyCommonOptions, applyServerOptions;
 var init_commands = __esm({
   "src/cli/commands.ts"() {
     "use strict";
     import_node_fs5 = require("fs");
     import_node_path28 = require("path");
-    import_shared60 = require("@rsbuild/shared");
+    import_shared49 = require("@rsbuild/shared");
     import_commander = require("../compiled/commander/index.js");
     init_helpers();
+    init_logger();
     init_init();
     applyCommonOptions = (command) => {
       command.option(
@@ -7350,21 +7616,22 @@ function prepareCli() {
   if (!npm_execpath || npm_execpath.includes("npx-cli.js") || npm_execpath.includes(".bun")) {
     console.log();
   }
-  import_shared61.logger.greet(`  ${`Rsbuild v${"0.7.8"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"0.7.9"}`}
 `);
 }
-var import_shared61;
 var init_prepare = __esm({
   "src/cli/prepare.ts"() {
     "use strict";
-    import_shared61 = require("@rsbuild/shared");
+    init_logger();
   }
 });
 
 // src/internal.ts
 var internal_exports = {};
 __export(internal_exports, {
+  TARGET_ID_MAP: () => TARGET_ID_MAP,
   applySwcDecoratorConfig: () => applySwcDecoratorConfig,
+  chainToConfig: () => chainToConfig,
   createDevServer: () => createDevServer,
   createPluginManager: () => createPluginManager,
   formatStats: () => formatStats,
@@ -7376,6 +7643,8 @@ __export(internal_exports, {
   initHooks: () => initHooks,
   initPlugins: () => initPlugins,
   initRsbuildConfig: () => initRsbuildConfig,
+  modifyBundlerChain: () => modifyBundlerChain,
+  onCompileDone: () => onCompileDone,
   outputInspectConfigFiles: () => outputInspectConfigFiles,
   prepareCli: () => prepareCli,
   runCli: () => runCli,
@@ -7394,10 +7663,12 @@ var init_internal = __esm({
     init_pluginHelper();
     init_helpers();
     init_rspackConfig();
+    init_configChain();
     init_swc();
     init_minimize();
     init_devMiddleware();
     init_devServer();
+    init_constants();
   }
 });
 
@@ -7412,7 +7683,7 @@ __export(src_exports, {
   ensureAssetPrefix: () => ensureAssetPrefix,
   loadConfig: () => loadConfig,
   loadEnv: () => loadEnv,
-  logger: () => import_shared62.logger,
+  logger: () => import_rslog.logger,
   mergeRsbuildConfig: () => mergeRsbuildConfig,
   rspack: () => import_core10.rspack,
   version: () => version
@@ -7423,11 +7694,11 @@ init_internal();
 init_loadEnv();
 init_createRsbuild();
 init_config();
-var import_shared62 = require("@rsbuild/shared");
+init_logger();
 init_mergeConfig();
 init_helpers();
 init_constants();
-var version = "0.7.8";
+var version = "0.7.9";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PLUGIN_CSS_NAME,