@rsbuild/core 1.0.9 → 1.0.11

package/dist/index.cjs

@@ -3101,6 +3101,122 @@ var init_esm = __esm({
   }
 });
 
+// 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_picocolors, import_rslog, isDebug;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    import_picocolors = __toESM(require("../compiled/picocolors/index.js"));
+    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_picocolors.default.gray(`${getTime()}`);
+        console.log(`  ${import_picocolors.default.magenta("rsbuild")} ${time} ${message}`, ...args);
+      }
+    });
+  }
+});
+
+// src/constants.ts
+var import_node_path, ROOT_DIST_DIR, HTML_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, HMR_SOCKET_PATH, RSBUILD_OUTPUTS_PATH, DEFAULT_PORT, DEFAULT_DATA_URL_SIZE, DEFAULT_MOUNT_ID, DEFAULT_DEV_HOST, DEFAULT_ASSET_PREFIX, DEFAULT_WEB_BROWSERSLIST, DEFAULT_BROWSERSLIST, HTML_REGEX, JS_REGEX, SCRIPT_REGEX, CSS_REGEX, NODE_MODULES_REGEX, PLUGIN_SWC_NAME, PLUGIN_CSS_NAME, FONT_EXTENSIONS, IMAGE_EXTENSIONS, VIDEO_EXTENSIONS, AUDIO_EXTENSIONS;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    import_node_path = require("path");
+    ROOT_DIST_DIR = "dist";
+    HTML_DIST_DIR = "./";
+    JS_DIST_DIR = "static/js";
+    CSS_DIST_DIR = "static/css";
+    SVG_DIST_DIR = "static/svg";
+    FONT_DIST_DIR = "static/font";
+    WASM_DIST_DIR = "static/wasm";
+    IMAGE_DIST_DIR = "static/image";
+    MEDIA_DIST_DIR = "static/media";
+    LOADER_PATH = (0, import_node_path.join)(__dirname);
+    STATIC_PATH = (0, import_node_path.join)(__dirname, "../static");
+    COMPILED_PATH = (0, import_node_path.join)(__dirname, "../compiled");
+    TS_CONFIG_FILE = "tsconfig.json";
+    HMR_SOCKET_PATH = "/rsbuild-hmr";
+    RSBUILD_OUTPUTS_PATH = ".rsbuild";
+    DEFAULT_PORT = 3e3;
+    DEFAULT_DATA_URL_SIZE = 4096;
+    DEFAULT_MOUNT_ID = "root";
+    DEFAULT_DEV_HOST = "0.0.0.0";
+    DEFAULT_ASSET_PREFIX = "/";
+    DEFAULT_WEB_BROWSERSLIST = [
+      "chrome >= 87",
+      "edge >= 88",
+      "firefox >= 78",
+      "safari >= 14"
+    ];
+    DEFAULT_BROWSERSLIST = {
+      web: DEFAULT_WEB_BROWSERSLIST,
+      "web-worker": DEFAULT_WEB_BROWSERSLIST,
+      node: ["node >= 16"]
+    };
+    HTML_REGEX = /\.html$/;
+    JS_REGEX = /\.(?:js|mjs|cjs|jsx)$/;
+    SCRIPT_REGEX = /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/;
+    CSS_REGEX = /\.css$/;
+    NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/;
+    PLUGIN_SWC_NAME = "rsbuild:swc";
+    PLUGIN_CSS_NAME = "rsbuild:css";
+    FONT_EXTENSIONS = [
+      "woff",
+      "woff2",
+      "eot",
+      "ttf",
+      "otf",
+      "ttc"
+    ];
+    IMAGE_EXTENSIONS = [
+      "png",
+      "jpg",
+      "jpeg",
+      "pjpeg",
+      "pjp",
+      "gif",
+      "bmp",
+      "webp",
+      "ico",
+      "apng",
+      "avif",
+      "tif",
+      "tiff",
+      "jfif"
+    ];
+    VIDEO_EXTENSIONS = ["mp4", "webm", "ogg", "mov"];
+    AUDIO_EXTENSIONS = [
+      "mp3",
+      "wav",
+      "flac",
+      "aac",
+      "m4a",
+      "opus"
+    ];
+  }
+});
+
 // ../../node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js
 var require_cjs = __commonJS({
   "../../node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js"(exports, module2) {
@@ -3204,122 +3320,6 @@ var require_cjs = __commonJS({
   }
 });
 
-// src/constants.ts
-var import_node_path, ROOT_DIST_DIR, HTML_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, HMR_SOCKET_PATH, RSBUILD_OUTPUTS_PATH, DEFAULT_PORT, DEFAULT_DATA_URL_SIZE, DEFAULT_MOUNT_ID, DEFAULT_DEV_HOST, DEFAULT_ASSET_PREFIX, DEFAULT_WEB_BROWSERSLIST, DEFAULT_BROWSERSLIST, HTML_REGEX, JS_REGEX, SCRIPT_REGEX, CSS_REGEX, NODE_MODULES_REGEX, PLUGIN_SWC_NAME, PLUGIN_CSS_NAME, FONT_EXTENSIONS, IMAGE_EXTENSIONS, VIDEO_EXTENSIONS, AUDIO_EXTENSIONS;
-var init_constants = __esm({
-  "src/constants.ts"() {
-    "use strict";
-    import_node_path = require("path");
-    ROOT_DIST_DIR = "dist";
-    HTML_DIST_DIR = "./";
-    JS_DIST_DIR = "static/js";
-    CSS_DIST_DIR = "static/css";
-    SVG_DIST_DIR = "static/svg";
-    FONT_DIST_DIR = "static/font";
-    WASM_DIST_DIR = "static/wasm";
-    IMAGE_DIST_DIR = "static/image";
-    MEDIA_DIST_DIR = "static/media";
-    LOADER_PATH = (0, import_node_path.join)(__dirname);
-    STATIC_PATH = (0, import_node_path.join)(__dirname, "../static");
-    COMPILED_PATH = (0, import_node_path.join)(__dirname, "../compiled");
-    TS_CONFIG_FILE = "tsconfig.json";
-    HMR_SOCKET_PATH = "/rsbuild-hmr";
-    RSBUILD_OUTPUTS_PATH = ".rsbuild";
-    DEFAULT_PORT = 3e3;
-    DEFAULT_DATA_URL_SIZE = 4096;
-    DEFAULT_MOUNT_ID = "root";
-    DEFAULT_DEV_HOST = "0.0.0.0";
-    DEFAULT_ASSET_PREFIX = "/";
-    DEFAULT_WEB_BROWSERSLIST = [
-      "chrome >= 87",
-      "edge >= 88",
-      "firefox >= 78",
-      "safari >= 14"
-    ];
-    DEFAULT_BROWSERSLIST = {
-      web: DEFAULT_WEB_BROWSERSLIST,
-      "web-worker": DEFAULT_WEB_BROWSERSLIST,
-      node: ["node >= 16"]
-    };
-    HTML_REGEX = /\.html$/;
-    JS_REGEX = /\.(?:js|mjs|cjs|jsx)$/;
-    SCRIPT_REGEX = /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/;
-    CSS_REGEX = /\.css$/;
-    NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/;
-    PLUGIN_SWC_NAME = "rsbuild:swc";
-    PLUGIN_CSS_NAME = "rsbuild:css";
-    FONT_EXTENSIONS = [
-      "woff",
-      "woff2",
-      "eot",
-      "ttf",
-      "otf",
-      "ttc"
-    ];
-    IMAGE_EXTENSIONS = [
-      "png",
-      "jpg",
-      "jpeg",
-      "pjpeg",
-      "pjp",
-      "gif",
-      "bmp",
-      "webp",
-      "ico",
-      "apng",
-      "avif",
-      "tif",
-      "tiff",
-      "jfif"
-    ];
-    VIDEO_EXTENSIONS = ["mp4", "webm", "ogg", "mov"];
-    AUDIO_EXTENSIONS = [
-      "mp3",
-      "wav",
-      "flac",
-      "aac",
-      "m4a",
-      "opus"
-    ];
-  }
-});
-
-// 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_picocolors, import_rslog, isDebug;
-var init_logger = __esm({
-  "src/logger.ts"() {
-    "use strict";
-    import_picocolors = __toESM(require("../compiled/picocolors/index.js"));
-    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_picocolors.default.gray(`${getTime()}`);
-        console.log(`  ${import_picocolors.default.magenta("rsbuild")} ${time} ${message}`, ...args);
-      }
-    });
-  }
-});
-
 // src/helpers/fs.ts
 function isEmptyDir(path21) {
   const files = import_node_fs.default.readdirSync(path21);
@@ -3980,12 +3980,21 @@ var init_restart = __esm({
       }
     };
     restartDevServer = async ({
-      filePath
-    }) => {
-      clearConsole();
-      const filename = import_node_path5.default.basename(filePath);
-      import_rslog.logger.info(`Restart because ${import_picocolors4.default.yellow(filename)} is changed.
-`);
+      filePath,
+      clear = true
+    } = {}) => {
+      if (clear) {
+        clearConsole();
+      }
+      if (filePath) {
+        const filename = import_node_path5.default.basename(filePath);
+        import_rslog.logger.info(
+          `Restart server because ${import_picocolors4.default.yellow(filename)} is changed.
+`
+        );
+      } else {
+        import_rslog.logger.info("Restarting server...\n");
+      }
       for (const cleaner of cleaners) {
         await cleaner();
         cleaners = [];
@@ -4022,7 +4031,7 @@ function getDefaultEntry(root) {
 function defineConfig(config) {
   return config;
 }
-async function watchFiles(files, watchOptions) {
+async function watchFilesForRestart(files, watchOptions) {
   if (!files.length) {
     return;
   }
@@ -4194,8 +4203,10 @@ var init_config = __esm({
     getDefaultDevConfig = () => ({
       hmr: true,
       liveReload: true,
+      // Temporary placeholder, default: `${server.base}`
       assetPrefix: DEFAULT_ASSET_PREFIX,
       writeToDisk: false,
+      cliShortcuts: false,
       client: {
         path: HMR_SOCKET_PATH,
         port: "",
@@ -4208,6 +4219,7 @@ var init_config = __esm({
       port: DEFAULT_PORT,
       host: DEFAULT_DEV_HOST,
       open: false,
+      base: "/",
       htmlFallback: "index",
       compress: true,
       printUrls: true,
@@ -4271,6 +4283,7 @@ var init_config = __esm({
         image: IMAGE_DIST_DIR,
         media: MEDIA_DIST_DIR
       },
+      // Temporary placeholder, default: `${server.base}`
       assetPrefix: DEFAULT_ASSET_PREFIX,
       filename: {},
       charset: "utf8",
@@ -4315,6 +4328,16 @@ var init_config = __esm({
       const merged = mergeRsbuildConfig(createDefaultConfig(), config);
       merged.root ||= rootPath;
       merged.source ||= {};
+      if (merged.server?.base) {
+        if (config.dev?.assetPrefix === void 0) {
+          merged.dev ||= {};
+          merged.dev.assetPrefix = merged.server.base;
+        }
+        if (config.output?.assetPrefix === void 0) {
+          merged.output ||= {};
+          merged.output.assetPrefix = merged.server.base;
+        }
+      }
       if (!merged.source.tsconfigPath) {
         const tsconfigPath = (0, import_node_path6.join)(rootPath, TS_CONFIG_FILE);
         if (await isFileExists(tsconfigPath)) {
@@ -5982,7 +6005,7 @@ async function createContext(options, userConfig, bundlerType) {
   const rsbuildConfig = await withDefaultConfig(rootPath, userConfig);
   const cachePath = (0, import_node_path10.join)(rootPath, "node_modules", ".cache");
   return {
-    version: "1.0.9",
+    version: "1.0.11",
     rootPath,
     distPath: "",
     cachePath,
@@ -6860,20 +6883,110 @@ var init_createCompiler = __esm({
   }
 });
 
-// src/server/runner/asModule.ts
-var import_node_vm, SYNTHETIC_MODULES_STORE, asModule;
-var init_asModule = __esm({
-  "src/server/runner/asModule.ts"() {
-    "use strict";
-    import_node_vm = __toESM(require("vm"));
-    SYNTHETIC_MODULES_STORE = "__SYNTHETIC_MODULES_STORE";
-    asModule = async (something, context, unlinked) => {
-      if (something instanceof import_node_vm.default.Module) {
-        return something;
+// src/server/cliShortcuts.ts
+function setupCliShortcuts({
+  openPage,
+  closeServer,
+  printUrls,
+  restartServer,
+  customShortcuts
+}) {
+  let shortcuts = [
+    {
+      key: "c",
+      description: `${import_picocolors9.default.bold("c + enter")}  ${import_picocolors9.default.dim("clear console")}`,
+      action: () => {
+        console.clear();
       }
-      context[SYNTHETIC_MODULES_STORE] = context[SYNTHETIC_MODULES_STORE] || [];
-      const i = context[SYNTHETIC_MODULES_STORE].length;
-      context[SYNTHETIC_MODULES_STORE].push(something);
+    },
+    {
+      key: "o",
+      description: `${import_picocolors9.default.bold("o + enter")}  ${import_picocolors9.default.dim("open in browser")}`,
+      action: openPage
+    },
+    {
+      key: "q",
+      description: `${import_picocolors9.default.bold("q + enter")}  ${import_picocolors9.default.dim("quit process")}`,
+      action: async () => {
+        try {
+          await closeServer();
+        } finally {
+          process.exit(0);
+        }
+      }
+    },
+    restartServer ? {
+      key: "r",
+      description: `${import_picocolors9.default.bold("r + enter")}  ${import_picocolors9.default.dim("restart server")}`,
+      action: restartServer
+    } : null,
+    {
+      key: "u",
+      description: `${import_picocolors9.default.bold("u + enter")}  ${import_picocolors9.default.dim("show urls")}`,
+      action: printUrls
+    }
+  ].filter(Boolean);
+  if (customShortcuts) {
+    shortcuts = customShortcuts(shortcuts);
+    if (!Array.isArray(shortcuts)) {
+      throw new Error("`dev.cliShortcuts` must return an array of shortcuts.");
+    }
+  }
+  import_rslog.logger.log(
+    `  ➜ ${import_picocolors9.default.dim("press")} ${import_picocolors9.default.bold("h + enter")} ${import_picocolors9.default.dim("to show shortcuts")}
+`
+  );
+  const rl = import_node_readline.default.createInterface({
+    input: process.stdin
+  });
+  rl.on("line", (input) => {
+    if (input === "h") {
+      let message = `
+  ${import_picocolors9.default.bold(import_picocolors9.default.blue("Shortcuts:"))}
+`;
+      for (const shortcut of shortcuts) {
+        message += `  ${shortcut.description}
+`;
+      }
+      import_rslog.logger.log(message);
+    }
+    for (const shortcut of shortcuts) {
+      if (input === shortcut.key) {
+        shortcut.action();
+        return;
+      }
+    }
+  });
+  onBeforeRestartServer(() => {
+    rl.close();
+  });
+}
+var import_node_readline, import_picocolors9, isCliShortcutsEnabled;
+var init_cliShortcuts = __esm({
+  "src/server/cliShortcuts.ts"() {
+    "use strict";
+    import_node_readline = __toESM(require("readline"));
+    import_picocolors9 = __toESM(require("../compiled/picocolors/index.js"));
+    init_logger();
+    init_restart();
+    isCliShortcutsEnabled = (devConfig) => devConfig.cliShortcuts && process.stdin.isTTY && !process.env.CI;
+  }
+});
+
+// src/server/runner/asModule.ts
+var import_node_vm, SYNTHETIC_MODULES_STORE, asModule;
+var init_asModule = __esm({
+  "src/server/runner/asModule.ts"() {
+    "use strict";
+    import_node_vm = __toESM(require("vm"));
+    SYNTHETIC_MODULES_STORE = "__SYNTHETIC_MODULES_STORE";
+    asModule = async (something, context, unlinked) => {
+      if (something instanceof import_node_vm.default.Module) {
+        return something;
+      }
+      context[SYNTHETIC_MODULES_STORE] = context[SYNTHETIC_MODULES_STORE] || [];
+      const i = context[SYNTHETIC_MODULES_STORE].length;
+      context[SYNTHETIC_MODULES_STORE].push(something);
       const code = [.../* @__PURE__ */ new Set(["default", ...Object.keys(something)])].map(
         (name) => `const _${name} = ${SYNTHETIC_MODULES_STORE}[${i}]${name === "default" ? "" : `[${JSON.stringify(name)}]`}; export { _${name} as ${name}};`
       ).join("\n");
@@ -7279,123 +7392,471 @@ var init_environment = __esm({
   }
 });
 
-// src/server/middlewares.ts
-var import_node_path16, import_picocolors9, faviconFallbackMiddleware, getStatusCodeColor, getRequestLoggerMiddleware, notFoundMiddleware, isFileExists2, maybeHTMLRequest, postfixRE, getUrlPathname, getHtmlCompletionMiddleware, getHtmlFallbackMiddleware;
-var init_middlewares = __esm({
-  "src/server/middlewares.ts"() {
+// src/server/helper.ts
+function getURLMessages(urls, routes) {
+  if (routes.length === 1) {
+    return urls.map(({ label, url: url2 }) => {
+      const pathname = normalizeUrl(`${url2}${routes[0].pathname}`);
+      const prefix = `➜ ${import_picocolors10.default.dim(label.padEnd(10))}`;
+      return `  ${prefix}${import_picocolors10.default.cyan(pathname)}
+`;
+    }).join("");
+  }
+  let message = "";
+  const maxNameLength = Math.max(...routes.map((r) => r.entryName.length));
+  urls.forEach(({ label, url: url2 }, index) => {
+    if (index > 0) {
+      message += "\n";
+    }
+    message += `  ${`➜ ${label}`}
+`;
+    for (const r of routes) {
+      message += `  ${import_picocolors10.default.dim("-")} ${import_picocolors10.default.dim(
+        r.entryName.padEnd(maxNameLength + 4)
+      )}${import_picocolors10.default.cyan(normalizeUrl(`${url2}${r.pathname}`))}
+`;
+    }
+  });
+  return message;
+}
+function printServerURLs({
+  urls: originalUrls,
+  port,
+  routes,
+  protocol,
+  printUrls,
+  trailingLineBreak = true
+}) {
+  if (printUrls === false) {
+    return null;
+  }
+  let urls = originalUrls;
+  if (isFunction(printUrls)) {
+    const newUrls = printUrls({
+      urls: urls.map((item) => item.url),
+      port,
+      routes,
+      protocol
+    });
+    if (!newUrls) {
+      return null;
+    }
+    if (!Array.isArray(newUrls)) {
+      throw new Error(
+        `"server.printUrls" must return an array, but got ${typeof newUrls}.`
+      );
+    }
+    urls = newUrls.map((url2) => ({
+      url: url2,
+      label: getUrlLabel(url2)
+    }));
+  }
+  if (urls.length === 0 || routes.length === 0) {
+    return null;
+  }
+  let message = getURLMessages(urls, routes);
+  if (trailingLineBreak === false && message.endsWith("\n")) {
+    message = message.slice(0, -1);
+  }
+  import_rslog.logger.log(message);
+  return message;
+}
+function getServerTerminator(server) {
+  let listened = false;
+  const pendingSockets = /* @__PURE__ */ new Set();
+  const onConnection = (socket) => {
+    pendingSockets.add(socket);
+    socket.on("close", () => {
+      pendingSockets.delete(socket);
+    });
+  };
+  server.on("connection", onConnection);
+  server.on("secureConnection", onConnection);
+  server.once("listening", () => {
+    listened = true;
+  });
+  return () => new Promise((resolve2, reject) => {
+    for (const socket of pendingSockets) {
+      socket.destroy();
+    }
+    if (listened) {
+      server.close((err) => err ? reject(err) : resolve2());
+    } else {
+      resolve2();
+    }
+  });
+}
+var import_node_net, import_node_os, import_node_path16, import_picocolors10, normalizeUrl, formatPrefix, joinUrlSegments, stripBase, getRoutes, formatRoutes, getPort, getServerConfig, getIpv4Interfaces, isLoopbackHost, getHostInUrl, concatUrl, LOCAL_LABEL, NETWORK_LABEL, getUrlLabel, getAddressUrls, COMPILATION_ID_REGEX, getCompilationId;
+var init_helper = __esm({
+  "src/server/helper.ts"() {
     "use strict";
-    import_node_path16 = __toESM(require("path"));
-    import_picocolors9 = __toESM(require("../compiled/picocolors/index.js"));
+    import_node_net = __toESM(require("net"));
+    import_node_os = __toESM(require("os"));
+    import_node_path16 = require("path");
+    import_picocolors10 = __toESM(require("../compiled/picocolors/index.js"));
+    init_constants();
+    init_helpers();
     init_logger();
-    faviconFallbackMiddleware = (req, res, next) => {
-      if (req.url === "/favicon.ico") {
-        res.statusCode = 204;
-        res.end();
-      } else {
-        next();
-      }
-    };
-    getStatusCodeColor = (status) => {
-      if (status >= 500) {
-        return import_picocolors9.default.red;
-      }
-      if (status >= 400) {
-        return import_picocolors9.default.yellow;
-      }
-      if (status >= 300) {
-        return import_picocolors9.default.cyan;
+    normalizeUrl = (url2) => url2.replace(/([^:]\/)\/+/g, "$1");
+    formatPrefix = (input) => {
+      let prefix = input;
+      if (prefix?.startsWith("./")) {
+        prefix = prefix.replace("./", "");
       }
-      if (status >= 200) {
-        return import_picocolors9.default.green;
+      if (!prefix) {
+        return "/";
       }
-      return (res) => res;
-    };
-    getRequestLoggerMiddleware = async () => {
-      const { default: onFinished } = await import("../compiled/on-finished/index.js");
-      return (req, res, next) => {
-        const _startAt = process.hrtime();
-        const logRequest = () => {
-          const method = req.method;
-          const url2 = req.originalUrl || req.url;
-          const status = Number(res.statusCode);
-          const statusColor = getStatusCodeColor(status);
-          const endAt = process.hrtime();
-          const totalTime = (endAt[0] - _startAt[0]) * 1e3 + (endAt[1] - _startAt[1]) * 1e-6;
-          import_rslog.logger.debug(
-            `${statusColor(status)} ${method} ${import_picocolors9.default.gray(url2)} ${import_picocolors9.default.gray(
-              `${totalTime.toFixed(3)} ms`
-            )}`
-          );
-        };
-        onFinished(res, logRequest);
-        next();
-      };
+      const hasLeadingSlash = prefix.startsWith("/");
+      const hasTailSlash = prefix.endsWith("/");
+      return `${hasLeadingSlash ? "" : "/"}${prefix}${hasTailSlash ? "" : "/"}`;
     };
-    notFoundMiddleware = (_req, res, _next) => {
-      res.statusCode = 404;
-      res.end();
+    joinUrlSegments = (s1, s2) => {
+      if (!s1 || !s2) {
+        return s1 || s2 || "";
+      }
+      return addTrailingSlash(s1) + removeLeadingSlash(s2);
     };
-    isFileExists2 = async (filePath, outputFileSystem) => new Promise((resolve2) => {
-      outputFileSystem.stat(filePath, (_error, stats) => {
-        resolve2(stats?.isFile());
-      });
-    });
-    maybeHTMLRequest = (req) => {
-      if (
-        // require headers and url
-        !req.url || !req.headers || // only accept GET or HEAD
-        req.method !== "GET" && req.method !== "HEAD"
-      ) {
-        return false;
+    stripBase = (path21, base) => {
+      if (path21 === base) {
+        return "/";
       }
-      const { accept } = req.headers;
-      return typeof accept === "string" && (accept.includes("text/html") || accept.includes("*/*"));
+      const trailingSlashBase = addTrailingSlash(base);
+      return path21.startsWith(trailingSlashBase) ? path21.slice(trailingSlashBase.length - 1) : path21;
     };
-    postfixRE = /[?#].*$/;
-    getUrlPathname = (url2) => {
-      return url2.replace(postfixRE, "");
+    getRoutes = (context) => {
+      return Object.values(context.environments).reduce(
+        (prev, environmentContext) => {
+          const { distPath, config } = environmentContext;
+          const distPrefix = import_node_path16.posix.relative(context.distPath, distPath);
+          const routes = formatRoutes(
+            environmentContext.htmlPaths,
+            context.normalizedConfig.server.base,
+            import_node_path16.posix.join(distPrefix, config.output.distPath.html),
+            config.html.outputStructure
+          );
+          return prev.concat(...routes);
+        },
+        []
+      );
     };
-    getHtmlCompletionMiddleware = ({ distPath, callback, outputFileSystem }) => {
-      return async (req, res, next) => {
-        if (!maybeHTMLRequest(req)) {
-          return next();
-        }
-        const url2 = req.url;
-        const pathname = getUrlPathname(url2);
-        const rewrite = (newUrl) => {
-          req.url = newUrl;
-          return callback(req, res, (...args) => {
-            next(...args);
-          });
+    formatRoutes = (entry, base, distPathPrefix, outputStructure) => {
+      const prefix = joinUrlSegments(base, formatPrefix(distPathPrefix));
+      return Object.keys(entry).map((entryName) => {
+        const isIndex = entryName === "index" && outputStructure !== "nested";
+        const displayName = isIndex ? "" : entryName;
+        return {
+          entryName,
+          pathname: prefix + displayName
         };
-        if (pathname.endsWith("/")) {
-          const newUrl = `${pathname}index.html`;
-          const filePath = import_node_path16.default.join(distPath, newUrl);
-          if (await isFileExists2(filePath, outputFileSystem)) {
-            return rewrite(newUrl);
-          }
-        } else if (!import_node_path16.default.extname(pathname)) {
-          const newUrl = `${pathname}.html`;
-          const filePath = import_node_path16.default.join(distPath, newUrl);
-          if (await isFileExists2(filePath, outputFileSystem)) {
-            return rewrite(newUrl);
-          }
-        }
-        next();
-      };
+      }).sort((a) => a.entryName === "index" ? -1 : 1);
     };
-    getHtmlFallbackMiddleware = ({ htmlFallback, distPath, callback, outputFileSystem }) => {
-      return async (req, res, next) => {
-        if (!maybeHTMLRequest(req) || "/favicon.ico" === req.url || htmlFallback !== "index") {
-          return next();
-        }
-        const filePath = import_node_path16.default.join(distPath, "index.html");
+    getPort = async ({
+      host,
+      port,
+      strictPort,
+      tryLimits = 20
+    }) => {
+      if (typeof port === "string") {
+        port = Number.parseInt(port, 10);
+      }
+      if (strictPort) {
+        tryLimits = 1;
+      }
+      const original = port;
+      let found = false;
+      let attempts = 0;
+      while (!found && attempts <= tryLimits) {
+        try {
+          await new Promise((resolve2, reject) => {
+            const server = import_node_net.default.createServer();
+            server.unref();
+            server.on("error", reject);
+            server.listen({ port, host }, () => {
+              found = true;
+              server.close(resolve2);
+            });
+          });
+        } catch (e) {
+          if (e.code !== "EADDRINUSE") {
+            throw e;
+          }
+          port++;
+          attempts++;
+        }
+      }
+      if (port !== original) {
+        if (strictPort) {
+          throw new Error(
+            `Port "${original}" is occupied, please choose another one.`
+          );
+        }
+      }
+      return port;
+    };
+    getServerConfig = async ({
+      config
+    }) => {
+      const host = config.server.host || DEFAULT_DEV_HOST;
+      const originalPort = config.server.port || DEFAULT_PORT;
+      const port = await getPort({
+        host,
+        port: originalPort,
+        strictPort: config.server.strictPort || false
+      });
+      const https = Boolean(config.server.https) || false;
+      const portTip = port !== originalPort ? `Port ${originalPort} is in use, ${import_picocolors10.default.yellow(`using port ${port}.`)}` : void 0;
+      return {
+        port,
+        host,
+        https,
+        portTip
+      };
+    };
+    getIpv4Interfaces = () => {
+      const interfaces = import_node_os.default.networkInterfaces();
+      const ipv4Interfaces = /* @__PURE__ */ new Map();
+      for (const key of Object.keys(interfaces)) {
+        for (const detail of interfaces[key]) {
+          const familyV4Value = typeof detail.family === "string" ? "IPv4" : 4;
+          if (detail.family === familyV4Value && !ipv4Interfaces.has(detail.address)) {
+            ipv4Interfaces.set(detail.address, detail);
+          }
+        }
+      }
+      return Array.from(ipv4Interfaces.values());
+    };
+    isLoopbackHost = (host) => {
+      const loopbackHosts = [
+        "localhost",
+        "127.0.0.1",
+        "::1",
+        "0000:0000:0000:0000:0000:0000:0000:0001"
+      ];
+      return loopbackHosts.includes(host);
+    };
+    getHostInUrl = (host) => {
+      if (import_node_net.default.isIPv6(host)) {
+        return host === "::" ? "[::1]" : `[${host}]`;
+      }
+      return host;
+    };
+    concatUrl = ({
+      host,
+      port,
+      protocol
+    }) => `${protocol}://${host}:${port}`;
+    LOCAL_LABEL = "Local:  ";
+    NETWORK_LABEL = "Network:  ";
+    getUrlLabel = (url2) => {
+      try {
+        const { host } = new URL(url2);
+        return isLoopbackHost(host) ? LOCAL_LABEL : NETWORK_LABEL;
+      } catch (err) {
+        return NETWORK_LABEL;
+      }
+    };
+    getAddressUrls = ({
+      protocol = "http",
+      port,
+      host
+    }) => {
+      if (host && host !== DEFAULT_DEV_HOST) {
+        return [
+          {
+            label: isLoopbackHost(host) ? LOCAL_LABEL : NETWORK_LABEL,
+            url: concatUrl({
+              port,
+              host: getHostInUrl(host),
+              protocol
+            })
+          }
+        ];
+      }
+      const ipv4Interfaces = getIpv4Interfaces();
+      const addressUrls = [];
+      let hasLocalUrl = false;
+      for (const detail of ipv4Interfaces) {
+        if (isLoopbackHost(detail.address) || detail.internal) {
+          if (hasLocalUrl) {
+            continue;
+          }
+          addressUrls.push({
+            label: LOCAL_LABEL,
+            url: concatUrl({ host: "localhost", port, protocol })
+          });
+          hasLocalUrl = true;
+        } else {
+          addressUrls.push({
+            label: NETWORK_LABEL,
+            url: concatUrl({ host: detail.address, port, protocol })
+          });
+        }
+      }
+      return addressUrls;
+    };
+    COMPILATION_ID_REGEX = /[^a-zA-Z0-9_-]/g;
+    getCompilationId = (compiler) => {
+      const uniqueName = compiler.options.output.uniqueName ?? "";
+      return `${compiler.name ?? ""}_${uniqueName.replace(COMPILATION_ID_REGEX, "_")}`;
+    };
+  }
+});
+
+// src/server/middlewares.ts
+var import_node_path17, import_picocolors11, faviconFallbackMiddleware, getStatusCodeColor, getRequestLoggerMiddleware, notFoundMiddleware, isFileExists2, maybeHTMLRequest, postfixRE, getUrlPathname, getHtmlCompletionMiddleware, getBaseMiddleware, getHtmlFallbackMiddleware;
+var init_middlewares = __esm({
+  "src/server/middlewares.ts"() {
+    "use strict";
+    import_node_path17 = __toESM(require("path"));
+    import_picocolors11 = __toESM(require("../compiled/picocolors/index.js"));
+    init_helpers();
+    init_logger();
+    init_helper();
+    faviconFallbackMiddleware = (req, res, next) => {
+      if (req.url === "/favicon.ico") {
+        res.statusCode = 204;
+        res.end();
+      } else {
+        next();
+      }
+    };
+    getStatusCodeColor = (status) => {
+      if (status >= 500) {
+        return import_picocolors11.default.red;
+      }
+      if (status >= 400) {
+        return import_picocolors11.default.yellow;
+      }
+      if (status >= 300) {
+        return import_picocolors11.default.cyan;
+      }
+      if (status >= 200) {
+        return import_picocolors11.default.green;
+      }
+      return (res) => res;
+    };
+    getRequestLoggerMiddleware = async () => {
+      const { default: onFinished } = await import("../compiled/on-finished/index.js");
+      return (req, res, next) => {
+        const _startAt = process.hrtime();
+        const logRequest = () => {
+          const method = req.method;
+          const url2 = req.originalUrl || req.url;
+          const status = Number(res.statusCode);
+          const statusColor = getStatusCodeColor(status);
+          const endAt = process.hrtime();
+          const totalTime = (endAt[0] - _startAt[0]) * 1e3 + (endAt[1] - _startAt[1]) * 1e-6;
+          import_rslog.logger.debug(
+            `${statusColor(status)} ${method} ${import_picocolors11.default.gray(url2)} ${import_picocolors11.default.gray(
+              `${totalTime.toFixed(3)} ms`
+            )}`
+          );
+        };
+        onFinished(res, logRequest);
+        next();
+      };
+    };
+    notFoundMiddleware = (_req, res, _next) => {
+      res.statusCode = 404;
+      res.end();
+    };
+    isFileExists2 = async (filePath, outputFileSystem) => new Promise((resolve2) => {
+      outputFileSystem.stat(filePath, (_error, stats) => {
+        resolve2(stats?.isFile());
+      });
+    });
+    maybeHTMLRequest = (req) => {
+      if (
+        // require headers and url
+        !req.url || !req.headers || // only accept GET or HEAD
+        req.method !== "GET" && req.method !== "HEAD"
+      ) {
+        return false;
+      }
+      const { accept } = req.headers;
+      return typeof accept === "string" && (accept.includes("text/html") || accept.includes("*/*"));
+    };
+    postfixRE = /[?#].*$/;
+    getUrlPathname = (url2) => {
+      return url2.replace(postfixRE, "");
+    };
+    getHtmlCompletionMiddleware = ({ distPath, callback, outputFileSystem }) => {
+      return async (req, res, next) => {
+        if (!maybeHTMLRequest(req)) {
+          return next();
+        }
+        const url2 = req.url;
+        const pathname = getUrlPathname(url2);
+        const rewrite = (newUrl) => {
+          req.url = newUrl;
+          return callback(req, res, (...args) => {
+            next(...args);
+          });
+        };
+        if (pathname.endsWith("/")) {
+          const newUrl = `${pathname}index.html`;
+          const filePath = import_node_path17.default.join(distPath, newUrl);
+          if (await isFileExists2(filePath, outputFileSystem)) {
+            return rewrite(newUrl);
+          }
+        } else if (!import_node_path17.default.extname(pathname)) {
+          const newUrl = `${pathname}.html`;
+          const filePath = import_node_path17.default.join(distPath, newUrl);
+          if (await isFileExists2(filePath, outputFileSystem)) {
+            return rewrite(newUrl);
+          }
+        }
+        next();
+      };
+    };
+    getBaseMiddleware = ({
+      base
+    }) => {
+      return async (req, res, next) => {
+        const url2 = req.url;
+        const pathname = getUrlPathname(url2);
+        if (pathname.startsWith(base)) {
+          req.url = stripBase(url2, base);
+          return next();
+        }
+        const redirectPath = addTrailingSlash(url2) !== base ? joinUrlSegments(base, url2) : base;
+        if (pathname === "/" || pathname === "/index.html") {
+          res.writeHead(302, {
+            Location: redirectPath
+          });
+          res.end();
+          return;
+        }
+        if (req.headers.accept?.includes("text/html")) {
+          res.writeHead(404, {
+            "Content-Type": "text/html"
+          });
+          res.end(
+            `The server is configured with a base URL of ${base} - did you mean to visit <a href="${redirectPath}">${redirectPath}</a> instead?`
+          );
+          return;
+        }
+        res.writeHead(404, {
+          "Content-Type": "text/plain"
+        });
+        res.end(
+          `The server is configured with a base URL of ${base} - did you mean to visit ${redirectPath} instead?`
+        );
+        return;
+      };
+    };
+    getHtmlFallbackMiddleware = ({ htmlFallback, distPath, callback, outputFileSystem }) => {
+      return async (req, res, next) => {
+        if (!maybeHTMLRequest(req) || "/favicon.ico" === req.url || htmlFallback !== "index") {
+          return next();
+        }
+        const filePath = import_node_path17.default.join(distPath, "index.html");
         if (await isFileExists2(filePath, outputFileSystem)) {
           const newUrl = "/index.html";
           if (import_rslog.logger.level === "verbose") {
             import_rslog.logger.debug(
-              `${req.method} ${import_picocolors9.default.gray(
-                `${req.url} ${import_picocolors9.default.yellow("fallback")} to ${newUrl}`
+              `${req.method} ${import_picocolors11.default.gray(
+                `${req.url} ${import_picocolors11.default.yellow("fallback")} to ${newUrl}`
               )}`
             );
           }
@@ -7565,477 +8026,188 @@ var init_proxy = __esm({
             proxyMiddleware(req, res, next);
           }
         };
-        middlewares.push(middleware);
-        opts.ws && proxyMiddlewares.push(proxyMiddleware);
-      }
-      const handleUpgrade = (req, socket, head) => {
-        for (const middleware of proxyMiddlewares) {
-          if (typeof middleware.upgrade === "function") {
-            middleware.upgrade(req, socket, head);
-          }
-        }
-      };
-      return {
-        middlewares,
-        upgrade: handleUpgrade
-      };
-    };
-  }
-});
-
-// src/server/getDevMiddlewares.ts
-var import_node_path17, import_node_url2, applySetupMiddlewares, applyDefaultMiddlewares, getMiddlewares;
-var init_getDevMiddlewares = __esm({
-  "src/server/getDevMiddlewares.ts"() {
-    "use strict";
-    import_node_path17 = require("path");
-    import_node_url2 = __toESM(require("url"));
-    init_config();
-    init_logger();
-    init_middlewares();
-    applySetupMiddlewares = (dev, environments, compileMiddlewareAPI) => {
-      const setupMiddlewares = dev.setupMiddlewares || [];
-      const serverOptions = {
-        sockWrite: (type, data) => compileMiddlewareAPI?.sockWrite(type, data),
-        environments
-      };
-      const before = [];
-      const after = [];
-      for (const handler of setupMiddlewares) {
-        handler(
-          {
-            unshift: (...handlers) => before.unshift(...handlers),
-            push: (...handlers) => after.push(...handlers)
-          },
-          serverOptions
-        );
-      }
-      return { before, after };
-    };
-    applyDefaultMiddlewares = async ({
-      middlewares,
-      server,
-      compileMiddlewareAPI,
-      output,
-      pwd,
-      outputFileSystem
-    }) => {
-      const upgradeEvents = [];
-      if (server.compress) {
-        const { gzipMiddleware: gzipMiddleware2 } = await Promise.resolve().then(() => (init_gzipMiddleware(), gzipMiddleware_exports));
-        middlewares.push(gzipMiddleware2());
-      }
-      middlewares.push((req, res, next) => {
-        res.setHeader("Access-Control-Allow-Origin", "*");
-        const path21 = req.url ? import_node_url2.default.parse(req.url).pathname : "";
-        if (path21?.includes("hot-update")) {
-          res.setHeader("Access-Control-Allow-Credentials", "false");
-        }
-        const confHeaders = server.headers;
-        if (confHeaders) {
-          for (const [key, value] of Object.entries(confHeaders)) {
-            res.setHeader(key, value);
-          }
-        }
-        next();
-      });
-      if (server.proxy) {
-        const { createProxyMiddleware: createProxyMiddleware2 } = await Promise.resolve().then(() => (init_proxy(), proxy_exports));
-        const { middlewares: proxyMiddlewares, upgrade } = await createProxyMiddleware2(server.proxy);
-        upgradeEvents.push(upgrade);
-        for (const middleware of proxyMiddlewares) {
-          middlewares.push(middleware);
-        }
-      }
-      const { default: launchEditorMiddleware } = await import("../compiled/launch-editor-middleware/index.js");
-      middlewares.push(["/__open-in-editor", launchEditorMiddleware()]);
-      if (compileMiddlewareAPI) {
-        middlewares.push(compileMiddlewareAPI.middleware);
-        upgradeEvents.push(
-          compileMiddlewareAPI.onUpgrade.bind(compileMiddlewareAPI)
-        );
-        middlewares.push((req, res, next) => {
-          if (req.url?.endsWith(".hot-update.json") && req.method !== "OPTIONS") {
-            res.statusCode = 404;
-            res.end();
-          } else {
-            next();
-          }
-        });
-      }
-      const distPath = (0, import_node_path17.isAbsolute)(output.distPath) ? output.distPath : (0, import_node_path17.join)(pwd, output.distPath);
-      if (compileMiddlewareAPI) {
-        middlewares.push(
-          getHtmlCompletionMiddleware({
-            distPath,
-            callback: compileMiddlewareAPI.middleware,
-            outputFileSystem
-          })
-        );
-      }
-      const publicDirs = normalizePublicDirs(server?.publicDir);
-      for (const publicDir of publicDirs) {
-        const { default: sirv } = await import("../compiled/sirv/index.js");
-        const { name } = publicDir;
-        const normalizedPath = (0, import_node_path17.isAbsolute)(name) ? name : (0, import_node_path17.join)(pwd, name);
-        const assetMiddleware = sirv(normalizedPath, {
-          etag: true,
-          dev: true
-        });
-        middlewares.push(assetMiddleware);
-      }
-      if (compileMiddlewareAPI) {
-        middlewares.push(
-          getHtmlFallbackMiddleware({
-            distPath,
-            callback: compileMiddlewareAPI.middleware,
-            htmlFallback: server.htmlFallback,
-            outputFileSystem
-          })
-        );
-      }
-      if (server.historyApiFallback) {
-        const { default: connectHistoryApiFallback } = await import("../compiled/connect-history-api-fallback/index.js");
-        const historyApiFallbackMiddleware = connectHistoryApiFallback(
-          server.historyApiFallback === true ? {} : server.historyApiFallback
-        );
-        middlewares.push(historyApiFallbackMiddleware);
-        compileMiddlewareAPI?.middleware && middlewares.push(compileMiddlewareAPI.middleware);
-      }
-      middlewares.push(faviconFallbackMiddleware);
-      middlewares.push((req, res, next) => {
-        if (req.method === "OPTIONS") {
-          res.statusCode = 204;
-          res.setHeader("Content-Length", "0");
-          res.end();
-          return;
-        }
-        next();
-      });
-      return {
-        onUpgrade: (...args) => {
-          for (const cb of upgradeEvents) {
-            cb(...args);
+        middlewares.push(middleware);
+        opts.ws && proxyMiddlewares.push(proxyMiddleware);
+      }
+      const handleUpgrade = (req, socket, head) => {
+        for (const middleware of proxyMiddlewares) {
+          if (typeof middleware.upgrade === "function") {
+            middleware.upgrade(req, socket, head);
           }
         }
       };
-    };
-    getMiddlewares = async (options) => {
-      const middlewares = [];
-      const { environments, compileMiddlewareAPI } = options;
-      if (import_rslog.logger.level === "verbose") {
-        middlewares.push(await getRequestLoggerMiddleware());
-      }
-      const { before, after } = applySetupMiddlewares(
-        options.dev,
-        environments,
-        compileMiddlewareAPI
-      );
-      middlewares.push(...before);
-      const { onUpgrade } = await applyDefaultMiddlewares({
-        ...options,
-        middlewares
-      });
-      middlewares.push(...after);
       return {
-        close: async () => {
-          compileMiddlewareAPI?.close();
-        },
-        onUpgrade,
-        middlewares
+        middlewares,
+        upgrade: handleUpgrade
       };
     };
   }
 });
 
-// src/server/helper.ts
-function getURLMessages(urls, routes) {
-  if (routes.length === 1) {
-    return urls.map(
-      ({ label, url: url2 }) => `  ${`➜ ${label.padEnd(10)}`}${import_picocolors10.default.cyan(
-        normalizeUrl(`${url2}${routes[0].pathname}`)
-      )}
-`
-    ).join("");
-  }
-  let message = "";
-  const maxNameLength = Math.max(...routes.map((r) => r.entryName.length));
-  urls.forEach(({ label, url: url2 }, index) => {
-    if (index > 0) {
-      message += "\n";
-    }
-    message += `  ${`➜ ${label}`}
-`;
-    for (const r of routes) {
-      message += `  ${import_picocolors10.default.dim("-")} ${import_picocolors10.default.dim(
-        r.entryName.padEnd(maxNameLength + 4)
-      )}${import_picocolors10.default.cyan(normalizeUrl(`${url2}${r.pathname}`))}
-`;
-    }
-  });
-  return message;
-}
-function printServerURLs({
-  urls: originalUrls,
-  port,
-  routes,
-  protocol,
-  printUrls
-}) {
-  if (printUrls === false) {
-    return null;
-  }
-  let urls = originalUrls;
-  if (isFunction(printUrls)) {
-    const newUrls = printUrls({
-      urls: urls.map((item) => item.url),
-      port,
-      routes,
-      protocol
-    });
-    if (!newUrls) {
-      return null;
-    }
-    if (!Array.isArray(newUrls)) {
-      throw new Error(
-        `"server.printUrls" must return an array, but got ${typeof newUrls}.`
-      );
-    }
-    urls = newUrls.map((url2) => ({
-      url: url2,
-      label: getUrlLabel(url2)
-    }));
-  }
-  if (urls.length === 0 || routes.length === 0) {
-    return null;
-  }
-  const message = getURLMessages(urls, routes);
-  import_rslog.logger.log(message);
-  return message;
-}
-function getServerTerminator(server) {
-  let listened = false;
-  const pendingSockets = /* @__PURE__ */ new Set();
-  const onConnection = (socket) => {
-    pendingSockets.add(socket);
-    socket.on("close", () => {
-      pendingSockets.delete(socket);
-    });
-  };
-  server.on("connection", onConnection);
-  server.on("secureConnection", onConnection);
-  server.once("listening", () => {
-    listened = true;
-  });
-  return () => new Promise((resolve2, reject) => {
-    for (const socket of pendingSockets) {
-      socket.destroy();
-    }
-    if (listened) {
-      server.close((err) => err ? reject(err) : resolve2());
-    } else {
-      resolve2();
-    }
-  });
-}
-var import_node_net, import_node_os, import_node_path18, import_picocolors10, normalizeUrl, formatPrefix, getRoutes, formatRoutes, getPort, getServerConfig, getIpv4Interfaces, isLoopbackHost, getHostInUrl, concatUrl, LOCAL_LABEL, NETWORK_LABEL, getUrlLabel, getAddressUrls, COMPILATION_ID_REGEX, getCompilationId;
-var init_helper = __esm({
-  "src/server/helper.ts"() {
+// src/server/getDevMiddlewares.ts
+var import_node_path18, import_node_url2, applySetupMiddlewares, applyDefaultMiddlewares, getMiddlewares;
+var init_getDevMiddlewares = __esm({
+  "src/server/getDevMiddlewares.ts"() {
     "use strict";
-    import_node_net = __toESM(require("net"));
-    import_node_os = __toESM(require("os"));
     import_node_path18 = require("path");
-    import_picocolors10 = __toESM(require("../compiled/picocolors/index.js"));
-    init_constants();
-    init_helpers();
+    import_node_url2 = __toESM(require("url"));
+    init_config();
     init_logger();
-    normalizeUrl = (url2) => url2.replace(/([^:]\/)\/+/g, "$1");
-    formatPrefix = (input) => {
-      let prefix = input;
-      if (prefix?.startsWith("./")) {
-        prefix = prefix.replace("./", "");
-      }
-      if (!prefix) {
-        return "/";
+    init_middlewares();
+    applySetupMiddlewares = (dev, environments, compileMiddlewareAPI) => {
+      const setupMiddlewares = dev.setupMiddlewares || [];
+      const serverOptions = {
+        sockWrite: (type, data) => compileMiddlewareAPI?.sockWrite(type, data),
+        environments
+      };
+      const before = [];
+      const after = [];
+      for (const handler of setupMiddlewares) {
+        handler(
+          {
+            unshift: (...handlers) => before.unshift(...handlers),
+            push: (...handlers) => after.push(...handlers)
+          },
+          serverOptions
+        );
       }
-      const hasLeadingSlash = prefix.startsWith("/");
-      const hasTailSlash = prefix.endsWith("/");
-      return `${hasLeadingSlash ? "" : "/"}${prefix}${hasTailSlash ? "" : "/"}`;
-    };
-    getRoutes = (context) => {
-      return Object.values(context.environments).reduce(
-        (prev, environmentContext) => {
-          const { distPath, config } = environmentContext;
-          const distPrefix = import_node_path18.posix.relative(context.distPath, distPath);
-          const routes = formatRoutes(
-            environmentContext.htmlPaths,
-            import_node_path18.posix.join(distPrefix, config.output.distPath.html),
-            config.html.outputStructure
-          );
-          return prev.concat(...routes);
-        },
-        []
-      );
-    };
-    formatRoutes = (entry, prefix, outputStructure) => {
-      const formattedPrefix = formatPrefix(prefix);
-      return Object.keys(entry).map((entryName) => {
-        const isIndex = entryName === "index" && outputStructure !== "nested";
-        const displayName = isIndex ? "" : entryName;
-        return {
-          entryName,
-          pathname: formattedPrefix + displayName
-        };
-      }).sort((a) => a.entryName === "index" ? -1 : 1);
+      return { before, after };
     };
-    getPort = async ({
-      host,
-      port,
-      strictPort,
-      tryLimits = 20
+    applyDefaultMiddlewares = async ({
+      middlewares,
+      server,
+      compileMiddlewareAPI,
+      output,
+      pwd,
+      outputFileSystem
     }) => {
-      if (typeof port === "string") {
-        port = Number.parseInt(port, 10);
-      }
-      if (strictPort) {
-        tryLimits = 1;
-      }
-      const original = port;
-      let found = false;
-      let attempts = 0;
-      while (!found && attempts <= tryLimits) {
-        try {
-          await new Promise((resolve2, reject) => {
-            const server = import_node_net.default.createServer();
-            server.unref();
-            server.on("error", reject);
-            server.listen({ port, host }, () => {
-              found = true;
-              server.close(resolve2);
-            });
-          });
-        } catch (e) {
-          if (e.code !== "EADDRINUSE") {
-            throw e;
-          }
-          port++;
-          attempts++;
-        }
-      }
-      if (port !== original) {
-        if (strictPort) {
-          throw new Error(
-            `Port "${original}" is occupied, please choose another one.`
-          );
-        }
+      const upgradeEvents = [];
+      if (server.compress) {
+        const { gzipMiddleware: gzipMiddleware2 } = await Promise.resolve().then(() => (init_gzipMiddleware(), gzipMiddleware_exports));
+        middlewares.push(gzipMiddleware2());
       }
-      return port;
-    };
-    getServerConfig = async ({
-      config
-    }) => {
-      const host = config.server.host || DEFAULT_DEV_HOST;
-      const originalPort = config.server.port || DEFAULT_PORT;
-      const port = await getPort({
-        host,
-        port: originalPort,
-        strictPort: config.server.strictPort || false
-      });
-      const https = Boolean(config.server.https) || false;
-      const portTip = port !== originalPort ? `Port ${originalPort} is in use, ${import_picocolors10.default.yellow(`using port ${port}.`)}` : void 0;
-      return {
-        port,
-        host,
-        https,
-        portTip
-      };
-    };
-    getIpv4Interfaces = () => {
-      const interfaces = import_node_os.default.networkInterfaces();
-      const ipv4Interfaces = /* @__PURE__ */ new Map();
-      for (const key of Object.keys(interfaces)) {
-        for (const detail of interfaces[key]) {
-          const familyV4Value = typeof detail.family === "string" ? "IPv4" : 4;
-          if (detail.family === familyV4Value && !ipv4Interfaces.has(detail.address)) {
-            ipv4Interfaces.set(detail.address, detail);
+      middlewares.push((req, res, next) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        const path21 = req.url ? import_node_url2.default.parse(req.url).pathname : "";
+        if (path21?.includes("hot-update")) {
+          res.setHeader("Access-Control-Allow-Credentials", "false");
+        }
+        const confHeaders = server.headers;
+        if (confHeaders) {
+          for (const [key, value] of Object.entries(confHeaders)) {
+            res.setHeader(key, value);
           }
         }
+        next();
+      });
+      if (server.proxy) {
+        const { createProxyMiddleware: createProxyMiddleware2 } = await Promise.resolve().then(() => (init_proxy(), proxy_exports));
+        const { middlewares: proxyMiddlewares, upgrade } = await createProxyMiddleware2(server.proxy);
+        upgradeEvents.push(upgrade);
+        for (const middleware of proxyMiddlewares) {
+          middlewares.push(middleware);
+        }
       }
-      return Array.from(ipv4Interfaces.values());
-    };
-    isLoopbackHost = (host) => {
-      const loopbackHosts = [
-        "localhost",
-        "127.0.0.1",
-        "::1",
-        "0000:0000:0000:0000:0000:0000:0000:0001"
-      ];
-      return loopbackHosts.includes(host);
-    };
-    getHostInUrl = (host) => {
-      if (import_node_net.default.isIPv6(host)) {
-        return host === "::" ? "[::1]" : `[${host}]`;
-      }
-      return host;
-    };
-    concatUrl = ({
-      host,
-      port,
-      protocol
-    }) => `${protocol}://${host}:${port}`;
-    LOCAL_LABEL = "Local:  ";
-    NETWORK_LABEL = "Network:  ";
-    getUrlLabel = (url2) => {
-      try {
-        const { host } = new URL(url2);
-        return isLoopbackHost(host) ? LOCAL_LABEL : NETWORK_LABEL;
-      } catch (err) {
-        return NETWORK_LABEL;
+      if (server.base && server.base !== "/") {
+        middlewares.push(getBaseMiddleware({ base: server.base }));
       }
-    };
-    getAddressUrls = ({
-      protocol = "http",
-      port,
-      host
-    }) => {
-      if (host && host !== DEFAULT_DEV_HOST) {
-        return [
-          {
-            label: isLoopbackHost(host) ? LOCAL_LABEL : NETWORK_LABEL,
-            url: concatUrl({
-              port,
-              host: getHostInUrl(host),
-              protocol
-            })
+      const { default: launchEditorMiddleware } = await import("../compiled/launch-editor-middleware/index.js");
+      middlewares.push(["/__open-in-editor", launchEditorMiddleware()]);
+      if (compileMiddlewareAPI) {
+        middlewares.push(compileMiddlewareAPI.middleware);
+        upgradeEvents.push(
+          compileMiddlewareAPI.onUpgrade.bind(compileMiddlewareAPI)
+        );
+        middlewares.push((req, res, next) => {
+          if (req.url?.endsWith(".hot-update.json") && req.method !== "OPTIONS") {
+            res.statusCode = 404;
+            res.end();
+          } else {
+            next();
           }
-        ];
+        });
       }
-      const ipv4Interfaces = getIpv4Interfaces();
-      const addressUrls = [];
-      let hasLocalUrl = false;
-      for (const detail of ipv4Interfaces) {
-        if (isLoopbackHost(detail.address) || detail.internal) {
-          if (hasLocalUrl) {
-            continue;
+      const distPath = (0, import_node_path18.isAbsolute)(output.distPath) ? output.distPath : (0, import_node_path18.join)(pwd, output.distPath);
+      if (compileMiddlewareAPI) {
+        middlewares.push(
+          getHtmlCompletionMiddleware({
+            distPath,
+            callback: compileMiddlewareAPI.middleware,
+            outputFileSystem
+          })
+        );
+      }
+      const publicDirs = normalizePublicDirs(server?.publicDir);
+      for (const publicDir of publicDirs) {
+        const { default: sirv } = await import("../compiled/sirv/index.js");
+        const { name } = publicDir;
+        const normalizedPath = (0, import_node_path18.isAbsolute)(name) ? name : (0, import_node_path18.join)(pwd, name);
+        const assetMiddleware = sirv(normalizedPath, {
+          etag: true,
+          dev: true
+        });
+        middlewares.push(assetMiddleware);
+      }
+      if (compileMiddlewareAPI) {
+        middlewares.push(
+          getHtmlFallbackMiddleware({
+            distPath,
+            callback: compileMiddlewareAPI.middleware,
+            htmlFallback: server.htmlFallback,
+            outputFileSystem
+          })
+        );
+      }
+      if (server.historyApiFallback) {
+        const { default: connectHistoryApiFallback } = await import("../compiled/connect-history-api-fallback/index.js");
+        const historyApiFallbackMiddleware = connectHistoryApiFallback(
+          server.historyApiFallback === true ? {} : server.historyApiFallback
+        );
+        middlewares.push(historyApiFallbackMiddleware);
+        compileMiddlewareAPI?.middleware && middlewares.push(compileMiddlewareAPI.middleware);
+      }
+      middlewares.push(faviconFallbackMiddleware);
+      middlewares.push((req, res, next) => {
+        if (req.method === "OPTIONS") {
+          res.statusCode = 204;
+          res.setHeader("Content-Length", "0");
+          res.end();
+          return;
+        }
+        next();
+      });
+      return {
+        onUpgrade: (...args) => {
+          for (const cb of upgradeEvents) {
+            cb(...args);
           }
-          addressUrls.push({
-            label: LOCAL_LABEL,
-            url: concatUrl({ host: "localhost", port, protocol })
-          });
-          hasLocalUrl = true;
-        } else {
-          addressUrls.push({
-            label: NETWORK_LABEL,
-            url: concatUrl({ host: detail.address, port, protocol })
-          });
         }
-      }
-      return addressUrls;
+      };
     };
-    COMPILATION_ID_REGEX = /[^a-zA-Z0-9_-]/g;
-    getCompilationId = (compiler) => {
-      const uniqueName = compiler.options.output.uniqueName ?? "";
-      return `${compiler.name ?? ""}_${uniqueName.replace(COMPILATION_ID_REGEX, "_")}`;
+    getMiddlewares = async (options) => {
+      const middlewares = [];
+      const { environments, compileMiddlewareAPI } = options;
+      if (import_rslog.logger.level === "verbose") {
+        middlewares.push(await getRequestLoggerMiddleware());
+      }
+      const { before, after } = applySetupMiddlewares(
+        options.dev,
+        environments,
+        compileMiddlewareAPI
+      );
+      middlewares.push(...before);
+      const { onUpgrade } = await applyDefaultMiddlewares({
+        ...options,
+        middlewares
+      });
+      middlewares.push(...after);
+      return {
+        close: async () => {
+          compileMiddlewareAPI?.close();
+        },
+        onUpgrade,
+        middlewares
+      };
     };
   }
 });
@@ -8216,7 +8388,7 @@ async function setupWatchFiles(options) {
   if (!hmr && !liveReload || !compileMiddlewareAPI) {
     return;
   }
-  const devFilesWatcher = await watchDevFiles(dev, compileMiddlewareAPI);
+  const closeDevFilesWatcher = await watchDevFiles(dev, compileMiddlewareAPI);
   const serverFilesWatcher = await watchServerFiles(
     server,
     compileMiddlewareAPI
@@ -8224,23 +8396,30 @@ async function setupWatchFiles(options) {
   return {
     async close() {
       await Promise.all([
-        devFilesWatcher?.close(),
+        closeDevFilesWatcher?.(),
         serverFilesWatcher?.close()
       ]);
     }
   };
 }
 async function watchDevFiles(devConfig, compileMiddlewareAPI) {
-  const { watchFiles: watchFiles2 } = devConfig;
-  if (!watchFiles2) {
+  const { watchFiles } = devConfig;
+  if (!watchFiles) {
     return;
   }
-  const watchOptions = prepareWatchOptions(
-    watchFiles2.paths,
-    watchFiles2.options,
-    watchFiles2.type
-  );
-  return startWatchFiles(watchOptions, compileMiddlewareAPI);
+  const watchers = [];
+  for (const { paths, options, type } of castArray(watchFiles)) {
+    const watchOptions = prepareWatchOptions(paths, options, type);
+    const watcher = await startWatchFiles(watchOptions, compileMiddlewareAPI);
+    if (watcher) {
+      watchers.push(watcher);
+    }
+  }
+  return async () => {
+    for (const watcher of watchers) {
+      await watcher.close();
+    }
+  };
 }
 function watchServerFiles(serverConfig, compileMiddlewareAPI) {
   const publicDirs = normalizePublicDirs(serverConfig.publicDir);
@@ -8276,6 +8455,7 @@ var init_watchFiles = __esm({
   "src/server/watchFiles.ts"() {
     "use strict";
     init_config();
+    init_helpers();
   }
 });
 
@@ -8606,6 +8786,7 @@ var init_compilerDevMiddleware = __esm({
     "use strict";
     init_path();
     init_devMiddleware();
+    init_helper();
     init_socketServer();
     noop = () => {
     };
@@ -8642,7 +8823,10 @@ var init_compilerDevMiddleware = __esm({
         });
       }
       setupDevMiddleware(devMiddleware, publicPaths) {
-        const { devConfig, serverConfig } = this;
+        const {
+          devConfig,
+          serverConfig: { headers, base }
+        } = this;
         const callbacks = {
           onInvalid: (compilationId) => {
             this.socketServer.sockWrite({
@@ -8656,7 +8840,7 @@ var init_compilerDevMiddleware = __esm({
         };
         const clientPaths = getClientPaths(devConfig);
         const middleware = devMiddleware({
-          headers: serverConfig.headers,
+          headers,
           publicPath: "/",
           stats: false,
           callbacks,
@@ -8669,7 +8853,9 @@ var init_compilerDevMiddleware = __esm({
           // https://developer.mozilla.org/en-US/docs/Web/HTTP/Conditional_requests#weak_validation
           etag: "weak"
         });
-        const assetPrefixes = publicPaths.map(pathnameParse);
+        const assetPrefixes = publicPaths.map(pathnameParse).map(
+          (prefix) => base && base !== "/" ? stripBase(prefix, base) : prefix
+        );
         const warp = async (req, res, next) => {
           const { url: url2 } = req;
           const assetPrefix = url2 && assetPrefixes.find((prefix) => url2.startsWith(prefix));
@@ -8751,22 +8937,47 @@ async function createDevServer(options, createCompiler2, config, {
   await options.context.hooks.onBeforeStartDevServer.call({
     environments: options.context.environments
   });
-  const printUrls = () => {
-    printServerURLs({
-      urls,
+  const cliShortcutsEnabled = isCliShortcutsEnabled(devConfig);
+  const printUrls = () => printServerURLs({
+    urls,
+    port,
+    routes,
+    protocol,
+    printUrls: config.server.printUrls,
+    trailingLineBreak: !cliShortcutsEnabled
+  });
+  const openPage = async () => {
+    return open({
+      https,
       port,
       routes,
-      protocol,
-      printUrls: config.server.printUrls
+      config,
+      clearCache: true
     });
+  };
+  const closeServer = async () => {
+    await options.context.hooks.onCloseDevServer.call();
+    await Promise.all([devMiddlewares.close(), fileWatcher?.close()]);
+  };
+  const beforeCreateCompiler = () => {
+    printUrls();
+    if (cliShortcutsEnabled) {
+      setupCliShortcuts({
+        openPage,
+        closeServer,
+        printUrls,
+        restartServer: () => restartDevServer({ clear: false }),
+        customShortcuts: typeof devConfig.cliShortcuts === "boolean" ? void 0 : devConfig.cliShortcuts.custom
+      });
+    }
     if (!getPortSilently && portTip) {
       import_rslog.logger.info(portTip);
     }
   };
   if (runCompile) {
-    options.context.hooks.onBeforeCreateCompiler.tap(printUrls);
+    options.context.hooks.onBeforeCreateCompiler.tap(beforeCreateCompiler);
   } else {
-    printUrls();
+    beforeCreateCompiler();
   }
   const compileMiddlewareAPI = runCompile ? await startCompile() : void 0;
   const fileWatcher = await setupWatchFiles({
@@ -8879,20 +9090,9 @@ async function createDevServer(options, createCompiler2, config, {
     connectWebSocket: ({ server }) => {
       server.on("upgrade", devMiddlewares.onUpgrade);
     },
-    close: async () => {
-      await options.context.hooks.onCloseDevServer.call();
-      await Promise.all([devMiddlewares.close(), fileWatcher?.close()]);
-    },
+    close: closeServer,
     printUrls,
-    open: async () => {
-      return open({
-        https,
-        port,
-        routes,
-        config,
-        clearCache: true
-      });
-    }
+    open: openPage
   };
   import_rslog.logger.debug("create dev server done");
   return devServerAPI;
@@ -8905,6 +9105,7 @@ var init_devServer = __esm({
     init_constants();
     init_helpers();
     init_logger();
+    init_cliShortcuts();
     init_environment();
     init_getDevMiddlewares();
     init_helper();
@@ -9130,11 +9331,11 @@ var entry_exports = {};
 __export(entry_exports, {
   pluginEntry: () => pluginEntry
 });
-var import_picocolors11, pluginEntry;
+var import_picocolors12, pluginEntry;
 var init_entry = __esm({
   "src/plugins/entry.ts"() {
     "use strict";
-    import_picocolors11 = __toESM(require("../compiled/picocolors/index.js"));
+    import_picocolors12 = __toESM(require("../compiled/picocolors/index.js"));
     init_helpers();
     pluginEntry = () => ({
       name: "rsbuild:entry",
@@ -9163,9 +9364,9 @@ var init_entry = __esm({
         api.onBeforeCreateCompiler(({ bundlerConfigs }) => {
           if (bundlerConfigs.every((config) => !config.entry)) {
             throw new Error(
-              `Could not find any entry module, please make sure that ${import_picocolors11.default.cyan(
+              `Could not find any entry module, please make sure that ${import_picocolors12.default.cyan(
                 "src/index.(ts|js|tsx|jsx|mjs|cjs)"
-              )} exists, or customize entry through the ${import_picocolors11.default.cyan(
+              )} exists, or customize entry through the ${import_picocolors12.default.cyan(
                 "source.entry"
               )} configuration.`
             );
@@ -9742,7 +9943,7 @@ function getHeader(longestFileLength, longestLabelLength, options) {
     }
     return `${prev + curLabel}    `;
   }, "  ");
-  return import_picocolors12.default.bold(import_picocolors12.default.blue(headerRow));
+  return import_picocolors13.default.bold(import_picocolors13.default.blue(headerRow));
 }
 async function printFileSizes(options, stats, rootPath) {
   const logs = [];
@@ -9815,7 +10016,7 @@ async function printFileSizes(options, stats, rootPath) {
         const rightPadding = " ".repeat(longestLabelLength - sizeLength);
         sizeLabel += rightPadding;
       }
-      let fileNameLabel = import_picocolors12.default.dim(asset.folder + import_node_path23.default.sep) + coloringAssetName(asset.name);
+      let fileNameLabel = import_picocolors13.default.dim(asset.folder + import_node_path23.default.sep) + coloringAssetName(asset.name);
       if (fileNameLength < longestFileLength) {
         const rightPadding = " ".repeat(longestFileLength - fileNameLength);
         fileNameLabel += rightPadding;
@@ -9828,15 +10029,15 @@ async function printFileSizes(options, stats, rootPath) {
     }
   }
   if (options.total !== false) {
-    const totalSizeLabel = `${import_picocolors12.default.bold(
-      import_picocolors12.default.blue("Total size:")
+    const totalSizeLabel = `${import_picocolors13.default.bold(
+      import_picocolors13.default.blue("Total size:")
     )}  ${calcFileSize(totalSize)}`;
     let log = `
   ${totalSizeLabel}
 `;
     if (options.compressed) {
-      const gzippedSizeLabel = `${import_picocolors12.default.bold(
-        import_picocolors12.default.blue("Gzipped size:")
+      const gzippedSizeLabel = `${import_picocolors13.default.bold(
+        import_picocolors13.default.blue("Gzipped size:")
       )}  ${calcFileSize(totalGzipSize)}`;
       log += `  ${gzippedSizeLabel}
 `;
@@ -9845,7 +10046,7 @@ async function printFileSizes(options, stats, rootPath) {
   }
   return logs;
 }
-var import_node_fs7, import_node_path23, import_node_util2, import_node_zlib2, import_picocolors12, gzip, filterAsset, getAssetColor, calcFileSize, coloringAssetName, pluginFileSize;
+var import_node_fs7, import_node_path23, import_node_util2, import_node_zlib2, import_picocolors13, gzip, filterAsset, getAssetColor, calcFileSize, coloringAssetName, pluginFileSize;
 var init_fileSize = __esm({
   "src/plugins/fileSize.ts"() {
     "use strict";
@@ -9853,19 +10054,19 @@ var init_fileSize = __esm({
     import_node_path23 = __toESM(require("path"));
     import_node_util2 = require("util");
     import_node_zlib2 = __toESM(require("zlib"));
-    import_picocolors12 = __toESM(require("../compiled/picocolors/index.js"));
+    import_picocolors13 = __toESM(require("../compiled/picocolors/index.js"));
     init_constants();
     init_logger();
     gzip = (0, import_node_util2.promisify)(import_node_zlib2.default.gzip);
     filterAsset = (asset) => !/\.map$/.test(asset) && !/\.LICENSE\.txt$/.test(asset);
     getAssetColor = (size) => {
       if (size > 300 * 1e3) {
-        return import_picocolors12.default.red;
+        return import_picocolors13.default.red;
       }
       if (size > 100 * 1e3) {
-        return import_picocolors12.default.yellow;
+        return import_picocolors13.default.yellow;
       }
-      return import_picocolors12.default.green;
+      return import_picocolors13.default.green;
     };
     calcFileSize = (len) => {
       const val = len / 1e3;
@@ -9873,15 +10074,15 @@ var init_fileSize = __esm({
     };
     coloringAssetName = (assetName) => {
       if (JS_REGEX.test(assetName)) {
-        return import_picocolors12.default.cyan(assetName);
+        return import_picocolors13.default.cyan(assetName);
       }
       if (CSS_REGEX.test(assetName)) {
-        return import_picocolors12.default.yellow(assetName);
+        return import_picocolors13.default.yellow(assetName);
       }
       if (HTML_REGEX.test(assetName)) {
-        return import_picocolors12.default.green(assetName);
+        return import_picocolors13.default.green(assetName);
       }
-      return import_picocolors12.default.magenta(assetName);
+      return import_picocolors13.default.magenta(assetName);
     };
     pluginFileSize = () => ({
       name: "rsbuild:file-size",
@@ -9911,7 +10112,7 @@ var init_fileSize = __esm({
                 multiStats[index],
                 api.context.rootPath
               );
-              const name = import_picocolors12.default.green(environment.name);
+              const name = import_picocolors13.default.green(environment.name);
               import_rslog.logger.info(`Production file sizes for ${name}:
 `);
               for (const log of statsLog) {
@@ -9934,12 +10135,12 @@ __export(cleanOutput_exports, {
   dedupeCleanPaths: () => dedupeCleanPaths,
   pluginCleanOutput: () => pluginCleanOutput
 });
-var import_node_path24, import_picocolors13, addTrailingSep, isStrictSubdir, dedupeCleanPaths, pluginCleanOutput;
+var import_node_path24, import_picocolors14, addTrailingSep, isStrictSubdir, dedupeCleanPaths, pluginCleanOutput;
 var init_cleanOutput = __esm({
   "src/plugins/cleanOutput.ts"() {
     "use strict";
     import_node_path24 = require("path");
-    import_picocolors13 = __toESM(require("../compiled/picocolors/index.js"));
+    import_picocolors14 = __toESM(require("../compiled/picocolors/index.js"));
     init_constants();
     init_helpers();
     init_logger();
@@ -9982,10 +10183,10 @@ var init_cleanOutput = __esm({
                 "The dist path is not a subdir of root path, Rsbuild will not empty it."
               );
               import_rslog.logger.warn(
-                `Please set ${import_picocolors13.default.yellow("`output.cleanDistPath`")} config manually.`
+                `Please set ${import_picocolors14.default.yellow("`output.cleanDistPath`")} config manually.`
               );
-              import_rslog.logger.warn(`Current root path: ${import_picocolors13.default.dim(rootPath)}`);
-              import_rslog.logger.warn(`Current dist path: ${import_picocolors13.default.dim(distPath)}`);
+              import_rslog.logger.warn(`Current root path: ${import_picocolors14.default.dim(rootPath)}`);
+              import_rslog.logger.warn(`Current dist path: ${import_picocolors14.default.dim(distPath)}`);
             }
           }
           if (cleanDistPath) {
@@ -10372,7 +10573,7 @@ async function getTemplate(entryName, config, rootPath) {
   if (!existTemplatePath.has(absolutePath)) {
     if (!await isFileExists(absolutePath)) {
       throw new Error(
-        `Failed to resolve HTML template, please check if the file exists: ${import_picocolors14.default.cyan(
+        `Failed to resolve HTML template, please check if the file exists: ${import_picocolors15.default.cyan(
           absolutePath
         )}`
       );
@@ -10458,13 +10659,13 @@ function getChunks(entryName, entryValue) {
   }
   return chunks;
 }
-var import_node_fs8, import_node_path27, import_picocolors14, getDefaultTemplateContent, existTemplatePath, getTagConfig, pluginHtml;
+var import_node_fs8, import_node_path27, import_picocolors15, getDefaultTemplateContent, existTemplatePath, getTagConfig, pluginHtml;
 var init_html = __esm({
   "src/plugins/html.ts"() {
     "use strict";
     import_node_fs8 = __toESM(require("fs"));
     import_node_path27 = __toESM(require("path"));
-    import_picocolors14 = __toESM(require("../compiled/picocolors/index.js"));
+    import_picocolors15 = __toESM(require("../compiled/picocolors/index.js"));
     init_dist2();
     init_helpers();
     getDefaultTemplateContent = (mountId) => `<!doctype html><html><head></head><body><div id="${mountId}"></div></body></html>`;
@@ -10881,13 +11082,16 @@ var init_define = __esm({
       setup(api) {
         api.modifyBundlerChain((chain, { CHAIN_ID: CHAIN_ID2, bundler, environment }) => {
           const { config } = environment;
+          const baseUrl = JSON.stringify(config.server.base);
+          const assetPrefix = JSON.stringify(getPublicPathFromChain(chain, false));
           const builtinVars = {
             "import.meta.env.MODE": JSON.stringify(config.mode),
             "import.meta.env.DEV": config.mode === "development",
             "import.meta.env.PROD": config.mode === "production",
-            "process.env.ASSET_PREFIX": JSON.stringify(
-              getPublicPathFromChain(chain, false)
-            )
+            "import.meta.env.BASE_URL": baseUrl,
+            "import.meta.env.ASSET_PREFIX": assetPrefix,
+            "process.env.BASE_URL": baseUrl,
+            "process.env.ASSET_PREFIX": assetPrefix
           };
           chain.plugin(CHAIN_ID2.PLUGIN.DEFINE).use(bundler.DefinePlugin, [
             { ...builtinVars, ...config.source.define }
@@ -11046,25 +11250,22 @@ __export(swc_exports, {
 });
 function applyScriptCondition({
   rule,
-  chain,
+  isDev,
   config,
   context,
-  includes,
-  excludes
+  rsbuildTarget
 }) {
   rule.include.add({
     and: [context.rootPath, { not: NODE_MODULES_REGEX }]
   });
   rule.include.add(/\.(?:ts|tsx|jsx|mts|cts)$/);
-  const target = castArray(chain.get("target"));
-  const legacyTarget = ["es5", "es6", "es2015", "es2016"];
-  if (legacyTarget.some((item) => target.includes(item))) {
+  if (rsbuildTarget === "web" && isDev) {
     rule.include.add(/[\\/]@rsbuild[\\/]core[\\/]dist[\\/]/);
   }
-  for (const condition of [...includes, ...config.source.include || []]) {
+  for (const condition of config.source.include || []) {
     rule.include.add(condition);
   }
-  for (const condition of [...excludes, ...config.source.exclude || []]) {
+  for (const condition of config.source.exclude || []) {
     rule.exclude.add(condition);
   }
 }
@@ -11139,7 +11340,7 @@ var init_swc = __esm({
       setup(api) {
         api.modifyBundlerChain({
           order: "pre",
-          handler: async (chain, { CHAIN_ID: CHAIN_ID2, target, environment }) => {
+          handler: async (chain, { CHAIN_ID: CHAIN_ID2, isDev, target, environment }) => {
             const { config, browserslist } = environment;
             const cacheRoot = import_node_path31.default.join(api.context.cachePath, ".swc");
             const rule = chain.module.rule(CHAIN_ID2.RULE.JS).test(SCRIPT_REGEX).type("javascript/auto");
@@ -11148,11 +11349,10 @@ var init_swc = __esm({
             });
             applyScriptCondition({
               rule,
-              chain,
+              isDev,
               config,
               context: api.context,
-              includes: [],
-              excludes: []
+              rsbuildTarget: target
             });
             if (api.context.bundlerType === "webpack") {
               return;
@@ -11665,11 +11865,11 @@ var rsdoctor_exports = {};
 __export(rsdoctor_exports, {
   pluginRsdoctor: () => pluginRsdoctor
 });
-var import_picocolors15, pluginRsdoctor;
+var import_picocolors16, pluginRsdoctor;
 var init_rsdoctor = __esm({
   "src/plugins/rsdoctor.ts"() {
     "use strict";
-    import_picocolors15 = __toESM(require("../compiled/picocolors/index.js"));
+    import_picocolors16 = __toESM(require("../compiled/picocolors/index.js"));
     init_logger();
     pluginRsdoctor = () => ({
       name: "rsbuild:rsdoctor",
@@ -11697,7 +11897,7 @@ var init_rsdoctor = __esm({
             });
           } catch (err) {
             import_rslog.logger.warn(
-              `\`process.env.RSDOCTOR\` enabled, please install ${import_picocolors15.default.bold(import_picocolors15.default.yellow(packageName))} package.`
+              `\`process.env.RSDOCTOR\` enabled, please install ${import_picocolors16.default.bold(import_picocolors16.default.yellow(packageName))} package.`
             );
             return;
           }
@@ -11706,7 +11906,7 @@ var init_rsdoctor = __esm({
             module2 = await import(packagePath);
           } catch (err) {
             import_rslog.logger.error(
-              `\`process.env.RSDOCTOR\` enabled, but failed to load ${import_picocolors15.default.bold(import_picocolors15.default.yellow(packageName))} module.`
+              `\`process.env.RSDOCTOR\` enabled, but failed to load ${import_picocolors16.default.bold(import_picocolors16.default.yellow(packageName))} module.`
             );
             return;
           }
@@ -11717,7 +11917,7 @@ var init_rsdoctor = __esm({
             config.plugins ||= [];
             config.plugins.push(new module2[pluginName]());
           }
-          import_rslog.logger.info(`${import_picocolors15.default.bold(import_picocolors15.default.yellow(packageName))} enabled.`);
+          import_rslog.logger.info(`${import_picocolors16.default.bold(import_picocolors16.default.yellow(packageName))} enabled.`);
         });
       }
     });
@@ -12848,24 +13048,44 @@ async function startProdServer(context, config, { getPortSilently } = {}) {
         });
         const protocol = https ? "https" : "http";
         const urls = getAddressUrls({ protocol, port, host });
-        printServerURLs({
+        const cliShortcutsEnabled = isCliShortcutsEnabled(config.dev);
+        const closeServer = async () => {
+          await Promise.all([server.close(), serverTerminator()]);
+        };
+        const printUrls = () => printServerURLs({
           urls,
           port,
           routes,
           protocol,
-          printUrls: serverConfig.printUrls
+          printUrls: serverConfig.printUrls,
+          trailingLineBreak: !cliShortcutsEnabled
         });
-        if (portTip && !getPortSilently) {
+        const openPage = async () => {
+          return open({
+            https,
+            port,
+            routes,
+            config,
+            clearCache: true
+          });
+        };
+        printUrls();
+        if (cliShortcutsEnabled) {
+          setupCliShortcuts({
+            openPage,
+            closeServer,
+            printUrls,
+            customShortcuts: typeof config.dev.cliShortcuts === "boolean" ? void 0 : config.dev.cliShortcuts.custom
+          });
+        }
+        if (!getPortSilently && portTip) {
           import_rslog.logger.info(portTip);
         }
-        const onClose = async () => {
-          await Promise.all([server.close(), serverTerminator()]);
-        };
         resolve2({
           port,
           urls: urls.map((item) => item.url),
           server: {
-            close: onClose
+            close: closeServer
           }
         });
       }
@@ -12878,9 +13098,11 @@ var init_prodServer = __esm({
     "use strict";
     init_path();
     init_logger();
+    init_cliShortcuts();
     init_helper();
     init_httpServer();
     init_middlewares();
+    init_open();
     RsbuildProdServer = class {
       constructor(options, middlewares) {
         __publicField(this, "app");
@@ -12895,7 +13117,7 @@ var init_prodServer = __esm({
         await this.applyDefaultMiddlewares();
       }
       async applyDefaultMiddlewares() {
-        const { headers, proxy, historyApiFallback, compress } = this.options.serverConfig;
+        const { headers, proxy, historyApiFallback, compress, base } = this.options.serverConfig;
         if (import_rslog.logger.level === "verbose") {
           this.middlewares.use(await getRequestLoggerMiddleware());
         }
@@ -12924,6 +13146,9 @@ var init_prodServer = __esm({
           }
           this.app.on("upgrade", upgrade);
         }
+        if (base && base !== "/") {
+          this.middlewares.use(getBaseMiddleware({ base }));
+        }
         this.applyStaticAssetMiddleware();
         if (historyApiFallback) {
           const { default: connectHistoryApiFallback } = await import("../compiled/connect-history-api-fallback/index.js");
@@ -13067,12 +13292,30 @@ async function createRsbuild(options = {}) {
     rsbuildOptions,
     setCssExtractPlugin
   });
-  const preview = async (options2) => {
+  const preview = async (options2 = {}) => {
     if (!getNodeEnv()) {
       setNodeEnv("production");
     }
-    const { startProdServer: startProdServer2 } = await Promise.resolve().then(() => (init_prodServer(), prodServer_exports));
     const config = await initRsbuildConfig({ context, pluginManager });
+    const { distPath } = context;
+    const { checkDistDir = true } = options2;
+    if (checkDistDir) {
+      if (!(0, import_node_fs12.existsSync)(distPath)) {
+        throw new Error(
+          `The output directory ${import_picocolors17.default.yellow(
+            distPath
+          )} does not exist, please build the project before previewing.`
+        );
+      }
+      if (isEmptyDir(distPath)) {
+        throw new Error(
+          `The output directory ${import_picocolors17.default.yellow(
+            distPath
+          )} is empty, please build the project before previewing.`
+        );
+      }
+    }
+    const { startProdServer: startProdServer2 } = await Promise.resolve().then(() => (init_prodServer(), prodServer_exports));
     return startProdServer2(context, config, options2);
   };
   const build2 = (...args) => {
@@ -13154,11 +13397,13 @@ async function createRsbuild(options = {}) {
   }
   return rsbuild;
 }
-var import_types3, getRspackProvider;
+var import_node_fs12, import_types3, import_picocolors17, getRspackProvider;
 var init_createRsbuild = __esm({
   "src/createRsbuild.ts"() {
     "use strict";
+    import_node_fs12 = require("fs");
     import_types3 = require("util/types");
+    import_picocolors17 = __toESM(require("../compiled/picocolors/index.js"));
     init_createContext();
     init_helpers();
     init_initPlugins();
@@ -13200,13 +13445,20 @@ async function init({
       if (configFilePath) {
         files.push(configFilePath);
       }
-      const { watchFiles: watchFilesConfig } = config.dev || {};
-      if (watchFilesConfig?.type === "reload-server") {
-        files.push(...castArray(watchFilesConfig.paths));
-        watchFiles(files, watchFilesConfig.options);
-      } else {
-        watchFiles(files);
+      if (config.dev?.watchFiles) {
+        for (const watchFilesConfig of castArray(config.dev.watchFiles)) {
+          if (watchFilesConfig.type === "reload-page") {
+            continue;
+          }
+          const paths = castArray(watchFilesConfig.paths);
+          if (watchFilesConfig.options) {
+            watchFilesForRestart(paths, watchFilesConfig.options);
+          } else {
+            files.push(...paths);
+          }
+        }
       }
+      watchFilesForRestart(files);
     }
     const { createRsbuild: createRsbuild2 } = await Promise.resolve().then(() => (init_createRsbuild(), createRsbuild_exports));
     config.source ||= {};
@@ -13232,6 +13484,10 @@ async function init({
       config.server ||= {};
       config.server.port = commonOpts.port;
     }
+    if (config.dev?.cliShortcuts === void 0) {
+      config.dev ||= {};
+      config.dev.cliShortcuts = true;
+    }
     return createRsbuild2({
       cwd: root,
       rsbuildConfig: config,
@@ -13267,7 +13523,7 @@ var init_init = __esm({
 
 // src/cli/commands.ts
 function runCli() {
-  program.name("rsbuild").usage("<command> [options]").version("1.0.9");
+  program.name("rsbuild").usage("<command> [options]").version("1.0.11");
   const devCommand = program.command("dev");
   const buildCommand = program.command("build");
   const previewCommand = program.command("preview");
@@ -13301,24 +13557,6 @@ function runCli() {
   previewCommand.description("preview the production build locally").action(async (options) => {
     try {
       const rsbuild = await init({ cliOptions: options });
-      await rsbuild?.initConfigs();
-      if (rsbuild) {
-        const { distPath } = rsbuild.context;
-        if (!(0, import_node_fs12.existsSync)(distPath)) {
-          throw new Error(
-            `The output directory ${import_picocolors16.default.yellow(
-              distPath
-            )} does not exist, please build the project before previewing.`
-          );
-        }
-        if (isEmptyDir(distPath)) {
-          throw new Error(
-            `The output directory ${import_picocolors16.default.yellow(
-              distPath
-            )} is empty, please build the project before previewing.`
-          );
-        }
-      }
       await rsbuild?.preview();
     } catch (err) {
       import_rslog.logger.error("Failed to start preview server.");
@@ -13342,14 +13580,11 @@ function runCli() {
   });
   program.parse();
 }
-var import_node_fs12, import_picocolors16, applyCommonOptions, applyServerOptions;
+var applyCommonOptions, applyServerOptions;
 var init_commands = __esm({
   "src/cli/commands.ts"() {
     "use strict";
-    import_node_fs12 = require("fs");
     init_esm();
-    import_picocolors16 = __toESM(require("../compiled/picocolors/index.js"));
-    init_helpers();
     init_logger();
     init_init();
     applyCommonOptions = (command) => {
@@ -13386,16 +13621,25 @@ function initNodeEnv() {
 }
 function prepareCli() {
   initNodeEnv();
+  const { enableCompileCache } = import_node_module.default;
+  if (enableCompileCache && !process.env.NODE_DISABLE_COMPILE_CACHE) {
+    try {
+      enableCompileCache();
+    } catch {
+    }
+  }
   const { npm_execpath } = process.env;
   if (!npm_execpath || npm_execpath.includes("npx-cli.js") || npm_execpath.includes(".bun")) {
     console.log();
   }
-  import_rslog.logger.greet(`  ${`Rsbuild v${"1.0.9"}`}
+  import_rslog.logger.greet(`  ${`Rsbuild v${"1.0.11"}`}
 `);
 }
+var import_node_module;
 var init_prepare = __esm({
   "src/cli/prepare.ts"() {
     "use strict";
+    import_node_module = __toESM(require("module"));
     init_logger();
   }
 });
@@ -13474,7 +13718,7 @@ init_logger();
 init_mergeConfig();
 init_helpers();
 init_constants();
-var version = "1.0.9";
+var version = "1.0.11";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PLUGIN_CSS_NAME,