@rsbuild/core 2.0.0 → 2.0.1

package/compiled/http-proxy-middleware/index.d.ts

@@ -10,7 +10,6 @@ import { HttpBindings } from '@hono/node-server';
 // @ts-ignore
 import { MiddlewareHandler } from 'hono';
 
-//#region src/types.d.ts
 interface ProxyTargetDetailed {
   host?: string;
   port?: number | string;
@@ -88,15 +87,11 @@ interface ProxyServerOptions {
   /** Buffer */
   buffer?: stream.Stream;
 }
-//#endregion
-//#region src/middleware/_utils.d.ts
 type ResOfType<T extends "web" | "ws"> = T extends "ws" ? T extends "web" ? ServerResponse | Http2ServerResponse | Socket : Socket : T extends "web" ? ServerResponse | Http2ServerResponse : never;
 type ProxyMiddleware<T extends ServerResponse | Http2ServerResponse | Socket> = (req: IncomingMessage | Http2ServerRequest, res: T, opts: ProxyServerOptions & {
   target: URL | ProxyTargetDetailed;
   forward: URL;
 }, server: ProxyServer<IncomingMessage | Http2ServerRequest, ServerResponse | Http2ServerResponse>, head?: Buffer, callback?: (err: any, req: IncomingMessage | Http2ServerRequest, socket: T, url?: any) => void) => void | true;
-//#endregion
-//#region src/server.d.ts
 interface ProxyServerEventMap<Req extends http__default.IncomingMessage | http2.Http2ServerRequest = http__default.IncomingMessage, Res extends http__default.ServerResponse | http2.Http2ServerResponse = http__default.ServerResponse> {
   error: [err: Error, req?: Req, res?: Res | net__default.Socket, target?: URL | ProxyTarget];
   start: [req: Req, res: Res, target: URL | ProxyTarget];
@@ -126,8 +121,9 @@ declare class ProxyServer<Req extends http__default.IncomingMessage | http2.Http
    * A function that wraps the object in a webserver, for your convenience
    * @param port - Port to listen on
    * @param hostname - The hostname to listen on
+   * @param listeningListener - A callback function that is called when the server starts listening
    */
-  listen(port: number, hostname?: string): this;
+  listen(port: number, hostname?: string, listeningListener?: () => void): this;
   /**
    * A function that closes the inner webserver and stops listening on given port
    */
@@ -164,6 +160,9 @@ interface OnProxyEvent<TReq extends http.IncomingMessage = http.IncomingMessage,
     econnreset?: (err: Error, req: TReq, res: TRes, target: string | Partial<URL>) => void;
 }
 type Logger = Pick<Console, 'info' | 'warn' | 'error'>;
+type PathRewriteConfig<TReq extends http.IncomingMessage = http.IncomingMessage> = {
+    [regexp: string]: string;
+} | ((path: string, req: TReq) => string | undefined) | ((path: string, req: TReq) => Promise<string>);
 interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes extends http.ServerResponse = http.ServerResponse> extends ProxyServerOptions {
     /**
      * Narrow down requests to proxy or not.
@@ -185,9 +184,7 @@ interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes
      * ```
      * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/pathRewrite.md
      */
-    pathRewrite?: {
-        [regexp: string]: string;
-    } | ((path: string, req: TReq) => string | undefined) | ((path: string, req: TReq) => Promise<string>);
+    pathRewrite?: PathRewriteConfig<TReq>;
     /**
      * Access the internal http-proxy server instance to customize behavior
      *
@@ -242,9 +239,7 @@ interface Options<TReq extends http.IncomingMessage = http.IncomingMessage, TRes
      * ```
      * @link https://github.com/chimurai/http-proxy-middleware/blob/master/recipes/router.md
      */
-    router?: {
-        [hostOrPath: string]: ProxyServerOptions['target'];
-    } | ((req: TReq) => ProxyServerOptions['target']) | ((req: TReq) => Promise<ProxyServerOptions['target']>);
+    router?: Record<string, ProxyServerOptions['target']> | ((req: TReq) => ProxyServerOptions['target']) | ((req: TReq) => Promise<ProxyServerOptions['target']>);
     /**
      * Log information from http-proxy-middleware
      * @example

package/compiled/http-proxy-middleware/package.json

@@ -1 +1 @@
-{"name":"http-proxy-middleware","author":"Steven Chim","version":"4.0.0-beta.3","license":"MIT","types":"index.d.ts","type":"module"}
+{"name":"http-proxy-middleware","author":"Steven Chim","version":"4.0.0-beta.4","license":"MIT","types":"index.d.ts","type":"module"}

package/dist/753.js

@@ -3467,7 +3467,7 @@ function createPublicContext(context) {
 async function createContext(options, userConfig, logger) {
     let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = join(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0;
     return {
-        version: "2.0.0",
+        version: "2.0.1",
         rootPath,
         distPath: '',
         cachePath,
@@ -4956,7 +4956,12 @@ function getInlineTests(config) {
         styleTests
     };
 }
-let normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1'), joinUrlSegments = (s1, s2)=>s1 && s2 ? addTrailingSlash(s1) + s2.replace(/^\/+/, '') : s1 || s2 || '', stripBase = (path, base)=>{
+let normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1'), formatPrefix = (input)=>{
+    let prefix = input;
+    if (prefix?.startsWith('./') && (prefix = prefix.replace('./', '')), !prefix) return '/';
+    let hasLeadingSlash = prefix.startsWith('/'), hasTailSlash = prefix.endsWith('/');
+    return `${hasLeadingSlash ? '' : '/'}${prefix}${hasTailSlash ? '' : '/'}`;
+}, joinUrlSegments = (s1, s2)=>s1 && s2 ? addTrailingSlash(s1) + s2.replace(/^\/+/, '') : s1 || s2 || '', stripBase = (path, base)=>{
     if (path === base) return '/';
     let trailingSlashBase = addTrailingSlash(base);
     return path.startsWith(trailingSlashBase) ? path.slice(trailingSlashBase.length - 1) : path;
@@ -4969,12 +4974,7 @@ let normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1'), joinUrlSegments = (
         return prev.concat(...routes);
     }, []);
 }, formatRoutes = (entry, base, distPathPrefix, outputStructure)=>{
-    let prefix = joinUrlSegments(base, ((input)=>{
-        let prefix = input;
-        if (prefix?.startsWith('./') && (prefix = prefix.replace('./', '')), !prefix) return '/';
-        let hasLeadingSlash = prefix.startsWith('/'), hasTailSlash = prefix.endsWith('/');
-        return `${hasLeadingSlash ? '' : '/'}${prefix}${hasTailSlash ? '' : '/'}`;
-    })(distPathPrefix));
+    let prefix = joinUrlSegments(base, formatPrefix(distPathPrefix));
     return Object.keys(entry).map((entryName)=>({
             entryName,
             pathname: prefix + ('index' === entryName && 'nested' !== outputStructure ? '' : entryName)
@@ -4993,7 +4993,7 @@ function getURLMessages(urls, routes) {
         for (let { entryName, pathname } of (prevLabel !== label && (index > 0 && (message += '\n'), message += `  ➜  ${label}\n`, prevLabel = label), routes))message += `  ${color.dim('-')}  ${color.dim(entryName.padEnd(maxNameLength + 4))}${color.cyan(normalizeUrl(`${url}${pathname}`))}\n`;
     }), message;
 }
-function printServerURLs({ urls: originalUrls, port, routes, protocol, printUrls, trailingLineBreak = !0, originalConfig, logger }) {
+function printServerURLs({ urls: originalUrls, port, routes, protocol, printUrls, fallbackPathname, trailingLineBreak = !0, originalConfig, logger }) {
     if (!1 === printUrls) return null;
     let urls = originalUrls, useCustomUrl = isFunction(printUrls);
     if (useCustomUrl) {
@@ -5015,8 +5015,15 @@ function printServerURLs({ urls: originalUrls, port, routes, protocol, printUrls
             };
         });
     }
-    if (0 === urls.length || 0 === routes.length && !useCustomUrl) return null;
-    let message = getURLMessages(urls, routes);
+    if (0 === urls.length) return null;
+    let printableRoutes = 0 !== routes.length || useCustomUrl || void 0 === fallbackPathname ? routes : [
+        {
+            entryName: 'index',
+            pathname: formatPrefix(fallbackPathname)
+        }
+    ];
+    if (0 === printableRoutes.length && !useCustomUrl) return null;
+    let message = getURLMessages(urls, printableRoutes);
     return originalConfig && originalConfig.server?.host === void 0 && (message += `  ➜  ${color.dim('Network:')}  ${color.dim('use')} ${color.bold('--host')} ${color.dim('to expose')}\n`), !trailingLineBreak && message.endsWith('\n') && (message = message.slice(0, -1)), logger.log(message), message;
 }
 let getPort = async ({ host, port, strictPort, tryLimits = 20 })=>{
@@ -6637,7 +6644,7 @@ function gzipMiddleware_gzipMiddleware({ filter, level = node_zlib.constants.Z_B
                 write(chunk) || gzip.pause();
             }), on('drain', ()=>gzip.resume()), gzip.on('end', ()=>{
                 end();
-            }), listeners))gzip.on.apply(gzip, listener);
+            }), listeners))gzip.on(...listener);
             else for (let listener of listeners)on.apply(res, listener);
             let statusCode = writeHeadStatus ?? res.statusCode;
             void 0 !== writeHeadMessage ? writeHead(statusCode, writeHeadMessage) : writeHead(statusCode);
@@ -7307,7 +7314,7 @@ async function startWatchFiles({ paths, options, type = 'reload-page' }, buildMa
 async function devServer_createDevServer(options, createCompiler, config, { getPortSilently, runCompile = !0 } = {}) {
     let lastStats, { context } = options, { logger } = context;
     logger.debug('create dev server');
-    let { port, portTip } = await resolvePort(config), { middlewareMode, host } = config.server, isHttps = !!config.server.https, routes = getRoutes(context);
+    let { port, portTip } = await resolvePort(config), { middlewareMode, host } = config.server, isHttps = !!config.server.https, routes = getRoutes(context), fallbackPathname = 0 === routes.length && context.environmentList.some((item)=>'web' === item.config.output.target) ? config.server.base : void 0;
     context.devServer = {
         hostname: host,
         port,
@@ -7349,6 +7356,7 @@ async function devServer_createDevServer(options, createCompiler, config, { getP
             routes,
             protocol,
             printUrls: config.server.printUrls,
+            fallbackPathname,
             trailingLineBreak: !cliShortcutsEnabled,
             originalConfig: context.originalConfig,
             logger
@@ -9186,7 +9194,7 @@ let applyServerOptions = (command)=>{
 };
 function setupCommands() {
     let cli = ((name = "")=>new CAC(name))('rsbuild');
-    cli.version("2.0.0"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
+    cli.version("2.0.1"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
         default: 'auto'
     }).option('--env-dir <dir>', 'Set the directory for loading `.env` files').option('--env-mode <mode>', 'Set the env mode to load the `.env.[mode]` file').option('--environment <name>', 'Set the environment name(s) to build', {
         type: [
@@ -9263,7 +9271,7 @@ function initNodeEnv() {
 }
 function showGreeting() {
     let { npm_execpath, npm_lifecycle_event, NODE_RUN_SCRIPT_NAME } = process.env, isBun = npm_execpath?.includes('.bun');
-    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.0\n`);
+    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.0.1\n`);
 }
 function setupLogLevel() {
     let logLevelIndex = process.argv.findIndex((item)=>'--log-level' === item || '--logLevel' === item);
@@ -9284,5 +9292,5 @@ function runCLI() {
         src_logger.error('Failed to start Rsbuild CLI.'), src_logger.error(err), process.exit(1);
     }
 }
-let src_version = "2.0.0";
+let src_version = "2.0.1";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, core_rspack as rspack, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger_createLogger as createLogger, mergeRsbuildConfig, runCLI, src_logger as logger, src_version as version };

package/dist/http-proxy-middleware.js

@@ -2226,7 +2226,7 @@ function setupOutgoing(outgoing, options, req, forward) {
     }, req.headers?.[":authority"] && (outgoing.headers.host = req.headers[":authority"]), options.headers) for (let key of Object.keys(options.headers))outgoing.headers[key] = options.headers[key];
     if (req.httpVersionMajor > 1) for (let header of HTTP2_HEADER_BLACKLIST)delete outgoing.headers[header];
     if (options.auth && (outgoing.auth = options.auth), options.ca && (outgoing.ca = options.ca), isSSL.test(options[forward || "target"].protocol ?? "http") && (outgoing.rejectUnauthorized = void 0 === options.secure || options.secure), void 0 !== options.agent) outgoing.agent = options.agent || !1;
-    else if (req.httpVersionMajor > 1) outgoing.agent = !1;
+    else if (req.httpVersionMajor > 1 || upgradeHeader.test(req.headers.connection || "")) outgoing.agent = !1;
     else {
         let targetProto = options[forward || "target"].protocol ?? "http";
         outgoing.agent = isSSL.test(targetProto) ? defaultAgents.https : defaultAgents.http;
@@ -2363,7 +2363,7 @@ let redirectStatuses = new Set([
             "proto"
         ]){
             let key = "x-forwarded-" + header;
-            req.headers[key] || (req.headers[key] = values[header]);
+            req.headers[key] || void 0 === values[header] || (req.headers[key] = values[header]);
         }
         req.headers["x-forwarded-host"] = req.headers["x-forwarded-host"] || req.headers[":authority"] || req.headers.host || "";
     },
@@ -2463,7 +2463,7 @@ let redirectStatuses = new Set([
             "proto"
         ]){
             let key = "x-forwarded-" + header;
-            req.headers[key] || (req.headers[key] = values[header]);
+            req.headers[key] || void 0 === values[header] || (req.headers[key] = values[header]);
         }
     },
     (req, socket, options, server, head, callback)=>{
@@ -2510,7 +2510,7 @@ var ERRORS, errors_ERRORS, ProxyServer = class extends EventEmitter {
     constructor(options = {}){
         super(), this.options = options || {}, this.options.prependPath = !1 !== options.prependPath, this.web = _createProxyFn("web", this), this.ws = _createProxyFn("ws", this);
     }
-    listen(port, hostname) {
+    listen(port, hostname, listeningListener) {
         let closure = (req, res)=>this.web(req, res);
         if (this.options.http2) {
             if (!this.options.ssl) throw Error("HTTP/2 requires ssl option");
@@ -2521,7 +2521,7 @@ var ERRORS, errors_ERRORS, ProxyServer = class extends EventEmitter {
         } else this.options.ssl ? this._server = node_https.createServer(this.options.ssl, closure) : this._server = node_http.createServer(closure);
         return this.options.ws && this._server.on("upgrade", (req, socket, head)=>{
             this.ws(req, socket, this.options, head).catch(()=>{});
-        }), this._server.listen(port, hostname), this;
+        }), this._server.listen(port, hostname, listeningListener), this;
     }
     close(callback) {
         this._server && this._server.close((...args)=>{
@@ -2793,7 +2793,7 @@ async function getTarget(req, config) {
     return isPlainObject(router) ? newTarget = getTargetFromProxyTable(req, router) : 'function' == typeof router && (newTarget = await router(req)), newTarget;
 }
 function getTargetFromProxyTable(req, table) {
-    let result, host = req.headers.host, hostAndPath = host + req.url;
+    let result, host = req.headers.host ?? '', hostAndPath = host + (req.url ?? '');
     for (let [key, value] of Object.entries(table))if (containsPath(key)) {
         if (hostAndPath.indexOf(key) > -1) {
             router_debug('match: "%s" -> "%s"', key, result = value);
@@ -2808,6 +2808,29 @@ function getTargetFromProxyTable(req, table) {
 function containsPath(v) {
     return v.indexOf('/') > -1;
 }
+let ipv6_debug = Debug.extend('ipv6');
+function normalizeIPv6LiteralTargets(options) {
+    options.target = normalizeIPv6ProxyTarget(options.target, 'target'), options.forward = normalizeIPv6ProxyTarget(options.forward, 'forward');
+}
+function normalizeIPv6ProxyTarget(target, optionName) {
+    let targetUrl = toTargetUrl(target);
+    return targetUrl && isBracketedIPv6Hostname(targetUrl.hostname) ? (ipv6_debug('normalized IPv6 "%s" %s', optionName, target), {
+        hostname: stripBrackets(targetUrl.hostname),
+        pathname: targetUrl.pathname,
+        port: targetUrl.port,
+        protocol: targetUrl.protocol,
+        search: targetUrl.search
+    }) : target;
+}
+function toTargetUrl(target) {
+    return 'string' == typeof target ? new URL(target) : target instanceof URL ? target : void 0;
+}
+function isBracketedIPv6Hostname(hostname) {
+    return hostname.startsWith('[') && hostname.endsWith(']');
+}
+function stripBrackets(hostname) {
+    return hostname.replace(/^\[|\]$/g, '');
+}
 class HttpProxyMiddleware {
     wsInternalSubscribed = !1;
     serverOnCloseSubscribed = !1;
@@ -2869,7 +2892,7 @@ class HttpProxyMiddleware {
     };
     prepareProxyRequest = async (req)=>{
         let newProxyOptions = Object.assign({}, this.proxyOptions);
-        return await this.applyRouter(req, newProxyOptions), await this.applyPathRewrite(req, this.pathRewriter), newProxyOptions;
+        return await this.applyRouter(req, newProxyOptions), normalizeIPv6LiteralTargets(newProxyOptions), await this.applyPathRewrite(req, this.pathRewriter), newProxyOptions;
     };
     applyRouter = async (req, options)=>{
         let newTarget;

package/dist-types/cli/init.d.ts

@@ -1,6 +1,6 @@
 import type { RsbuildInstance } from '../types';
 import type { CommonOptions } from './commands';
-export declare function init({ cliOptions, isRestart, isBuildWatch, }: {
+export declare function init({ cliOptions, isRestart, isBuildWatch }: {
     cliOptions?: CommonOptions;
     isRestart?: boolean;
     isBuildWatch?: boolean;

package/dist-types/configChain.d.ts

@@ -5,129 +5,129 @@ export declare const CHAIN_ID: {
     /** Predefined rules */
     readonly RULE: {
         /** Rule for .mjs */
-        readonly MJS: "mjs";
+        readonly MJS: 'mjs';
         /** Rule for fonts */
-        readonly FONT: "font";
+        readonly FONT: 'font';
         /** Rule for JSON */
-        readonly JSON: "json";
+        readonly JSON: 'json';
         /** Rule for images */
-        readonly IMAGE: "image";
+        readonly IMAGE: 'image';
         /** Rule for media */
-        readonly MEDIA: "media";
+        readonly MEDIA: 'media';
         /** Rule for additional assets */
-        readonly ADDITIONAL_ASSETS: "additional-assets";
+        readonly ADDITIONAL_ASSETS: 'additional-assets';
         /** Rule for JS */
-        readonly JS: "js";
+        readonly JS: 'js';
         /** Rule for data uri encoded javascript */
-        readonly JS_DATA_URI: "js-data-uri";
+        readonly JS_DATA_URI: 'js-data-uri';
         /** Rule for CSS */
-        readonly CSS: "css";
+        readonly CSS: 'css';
         /** Rule for Less */
-        readonly LESS: "less";
+        readonly LESS: 'less';
         /** Rule for Sass */
-        readonly SASS: "sass";
+        readonly SASS: 'sass';
         /** Rule for stylus */
-        readonly STYLUS: "stylus";
+        readonly STYLUS: 'stylus';
         /** Rule for svg */
-        readonly SVG: "svg";
+        readonly SVG: 'svg';
         /** Rule for Vue */
-        readonly VUE: "vue";
+        readonly VUE: 'vue';
         /** Rule for wasm */
-        readonly WASM: "wasm";
+        readonly WASM: 'wasm';
         /** Rule for svelte */
-        readonly SVELTE: "svelte";
+        readonly SVELTE: 'svelte';
     };
     /** Predefined rule groups */
     readonly ONE_OF: {
         /** JS oneOf rules */
-        readonly JS_MAIN: "js";
-        readonly JS_RAW: "js-raw";
+        readonly JS_MAIN: 'js';
+        readonly JS_RAW: 'js-raw';
         /** CSS oneOf rules */
-        readonly CSS_MAIN: "css";
-        readonly CSS_RAW: "css-raw";
-        readonly CSS_INLINE: "css-inline";
+        readonly CSS_MAIN: 'css';
+        readonly CSS_RAW: 'css-raw';
+        readonly CSS_INLINE: 'css-inline';
         /** SVG oneOf rules */
-        readonly SVG: "svg";
-        readonly SVG_RAW: "svg-asset-raw";
-        readonly SVG_URL: "svg-asset-url";
-        readonly SVG_ASSET: "svg-asset";
-        readonly SVG_REACT: "svg-react";
-        readonly SVG_INLINE: "svg-asset-inline";
+        readonly SVG: 'svg';
+        readonly SVG_RAW: 'svg-asset-raw';
+        readonly SVG_URL: 'svg-asset-url';
+        readonly SVG_ASSET: 'svg-asset';
+        readonly SVG_REACT: 'svg-react';
+        readonly SVG_INLINE: 'svg-asset-inline';
     };
     /** Predefined loaders */
     readonly USE: {
         /** ts-loader */
-        readonly TS: "ts";
+        readonly TS: 'ts';
         /** css-loader */
-        readonly CSS: "css";
+        readonly CSS: 'css';
         /** sass-loader */
-        readonly SASS: "sass";
+        readonly SASS: 'sass';
         /** less-loader */
-        readonly LESS: "less";
+        readonly LESS: 'less';
         /** stylus-loader */
-        readonly STYLUS: "stylus";
+        readonly STYLUS: 'stylus';
         /** url-loader */
-        readonly URL: "url";
+        readonly URL: 'url';
         /** vue-loader */
-        readonly VUE: "vue";
+        readonly VUE: 'vue';
         /** swc-loader */
-        readonly SWC: "swc";
+        readonly SWC: 'swc';
         /** svgr */
-        readonly SVGR: "svgr";
+        readonly SVGR: 'svgr';
         /** babel-loader */
-        readonly BABEL: "babel";
+        readonly BABEL: 'babel';
         /** style-loader */
-        readonly STYLE: "style-loader";
+        readonly STYLE: 'style-loader';
         /** svelte-loader */
-        readonly SVELTE: "svelte";
+        readonly SVELTE: 'svelte';
         /** postcss-loader */
-        readonly POSTCSS: "postcss";
+        readonly POSTCSS: 'postcss';
         /** lightningcss-loader */
-        readonly LIGHTNINGCSS: "lightningcss";
+        readonly LIGHTNINGCSS: 'lightningcss';
         /** ignore-css-loader */
-        readonly IGNORE_CSS: "ignore-css";
+        readonly IGNORE_CSS: 'ignore-css';
         /** CssExtractRspackPlugin.loader */
-        readonly MINI_CSS_EXTRACT: "mini-css-extract";
+        readonly MINI_CSS_EXTRACT: 'mini-css-extract';
         /** resolve-url-loader */
-        readonly RESOLVE_URL: "resolve-url-loader";
+        readonly RESOLVE_URL: 'resolve-url-loader';
     };
     /** Predefined plugins */
     readonly PLUGIN: {
         /** HotModuleReplacementPlugin */
-        readonly HMR: "hmr";
+        readonly HMR: 'hmr';
         /** CopyRspackPlugin */
-        readonly COPY: "copy";
+        readonly COPY: 'copy';
         /** HtmlRspackPlugin */
-        readonly HTML: "html";
+        readonly HTML: 'html';
         /** DefinePlugin */
-        readonly DEFINE: "define";
+        readonly DEFINE: 'define';
         /** ProgressPlugin */
-        readonly PROGRESS: "progress";
+        readonly PROGRESS: 'progress';
         /** RspackManifestPlugin */
-        readonly MANIFEST: "rspack-manifest";
+        readonly MANIFEST: 'rspack-manifest';
         /** ForkTsCheckerWebpackPlugin */
-        readonly TS_CHECKER: "ts-checker";
+        readonly TS_CHECKER: 'ts-checker';
         /** ModuleFederationPlugin */
-        readonly MODULE_FEDERATION: "module-federation";
+        readonly MODULE_FEDERATION: 'module-federation';
         /** HtmlResourceHintsPlugin (prefetch) */
-        readonly HTML_PREFETCH: "html-prefetch-plugin";
+        readonly HTML_PREFETCH: 'html-prefetch-plugin';
         /** HtmlResourceHintsPlugin (preload) */
-        readonly HTML_PRELOAD: "html-preload-plugin";
+        readonly HTML_PRELOAD: 'html-preload-plugin';
         /** CssExtractRspackPlugin */
-        readonly MINI_CSS_EXTRACT: "mini-css-extract";
+        readonly MINI_CSS_EXTRACT: 'mini-css-extract';
         /** VueLoaderPlugin */
-        readonly VUE_LOADER_PLUGIN: "vue-loader-plugin";
+        readonly VUE_LOADER_PLUGIN: 'vue-loader-plugin';
         /** ReactFastRefreshPlugin */
-        readonly REACT_FAST_REFRESH: "react-fast-refresh";
+        readonly REACT_FAST_REFRESH: 'react-fast-refresh';
         /** SubresourceIntegrityPlugin */
-        readonly SUBRESOURCE_INTEGRITY: "subresource-integrity";
+        readonly SUBRESOURCE_INTEGRITY: 'subresource-integrity';
     };
     /** Predefined minimizers */
     readonly MINIMIZER: {
         /** SwcJsMinimizerRspackPlugin */
-        readonly JS: "js";
+        readonly JS: 'js';
         /** LightningCssMinimizerRspackPlugin */
-        readonly CSS: "css";
+        readonly CSS: 'css';
     };
 };
 export type ChainIdentifier = typeof CHAIN_ID;

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

@@ -1,3 +1,3 @@
 import type { StatsError } from '@rspack/core';
 import { type Logger } from '../logger';
-export declare function formatStatsError(stats: StatsError, root: string, level: "error" | "warning" | undefined, logger: Logger): string;
+export declare function formatStatsError(stats: StatsError, root: string, level: ('error' | 'warning') | undefined, logger: Logger): string;

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

@@ -25,6 +25,6 @@ export declare const prettyTime: (seconds: number) => string;
 /**
  * Check if running in a TTY context
  */
-export declare const isTTY: (type?: "stdin" | "stdout") => boolean;
+export declare const isTTY: (type?: 'stdin' | 'stdout') => boolean;
 export declare function hash(data: string): Promise<string>;
 export declare const isRspackRuntimeModule: (identifier: string) => boolean;

package/dist-types/initConfigs.d.ts

@@ -13,7 +13,7 @@ export type InitConfigsOptions = {
  * 5. Run all the `modifyEnvironmentConfig` hooks
  * 6. Validate the final Rsbuild config
  */
-export declare function initRsbuildConfig({ context, pluginManager, }: Pick<InitConfigsOptions, 'context' | 'pluginManager'>): Promise<NormalizedConfig>;
-export declare function initConfigs({ context, pluginManager, rsbuildOptions, }: InitConfigsOptions): Promise<{
+export declare function initRsbuildConfig({ context, pluginManager }: Pick<InitConfigsOptions, 'context' | 'pluginManager'>): Promise<NormalizedConfig>;
+export declare function initConfigs({ context, pluginManager, rsbuildOptions }: InitConfigsOptions): Promise<{
     rspackConfigs: Rspack.Configuration[];
 }>;

package/dist-types/initPlugins.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from './logger';
 import type { InternalContext, NormalizedEnvironmentConfig, PluginManager, RsbuildPluginAPI } from './types';
 export declare function getHTMLPathByEntry(entryName: string, config: NormalizedEnvironmentConfig, logger: Logger): string;
-export declare function initPluginAPI({ context, pluginManager, }: {
+export declare function initPluginAPI({ context, pluginManager }: {
     context: InternalContext;
     pluginManager: PluginManager;
 }): (environment?: string) => RsbuildPluginAPI;

package/dist-types/inspectConfig.d.ts

@@ -1,7 +1,7 @@
 import type { InitConfigsOptions } from './initConfigs';
 import type { InspectConfigOptions, InspectConfigResult, Rspack } from './types';
 export declare function stringifyConfig(config: unknown, verbose?: boolean): string;
-export declare function inspectConfig({ context, pluginManager, bundlerConfigs, inspectOptions, }: InitConfigsOptions & {
+export declare function inspectConfig({ context, pluginManager, bundlerConfigs, inspectOptions }: InitConfigsOptions & {
     inspectOptions?: InspectConfigOptions;
     bundlerConfigs: Rspack.Configuration[];
 }): Promise<InspectConfigResult>;

package/dist-types/loadConfig.d.ts

@@ -57,4 +57,4 @@ export declare function defineConfig(config: RsbuildConfigSyncFn): RsbuildConfig
 export declare function defineConfig(config: RsbuildConfigAsyncFn): RsbuildConfigAsyncFn;
 export declare function defineConfig(config: RsbuildConfigExport): RsbuildConfigExport;
 export type ConfigLoader = 'auto' | 'jiti' | 'native';
-export declare function loadConfig({ cwd, path, envMode, meta, loader, }?: LoadConfigOptions): Promise<LoadConfigResult>;
+export declare function loadConfig({ cwd, path, envMode, meta, loader }?: LoadConfigOptions): Promise<LoadConfigResult>;

package/dist-types/loadEnv.d.ts

@@ -60,4 +60,4 @@ export type LoadEnvResult = {
      */
     cleanup: () => void;
 };
-export declare function loadEnv({ cwd, mode, prefixes, processEnv, }?: LoadEnvOptions): LoadEnvResult;
+export declare function loadEnv({ cwd, mode, prefixes, processEnv }?: LoadEnvOptions): LoadEnvResult;

package/dist-types/logger.d.ts

@@ -19,7 +19,7 @@
  */
 import { createLogger as baseCreateLogger, type Logger, logger as defaultLogger } from '../compiled/rslog';
 export declare const isDebug: () => boolean;
-export declare const isVerbose: (targetLogger: Pick<Logger, "level">) => boolean;
+export declare const isVerbose: (targetLogger: Pick<Logger, 'level'>) => boolean;
 export declare const createLogger: (...args: Parameters<typeof baseCreateLogger>) => ReturnType<typeof baseCreateLogger>;
 export { defaultLogger };
 export type { Logger };

package/dist-types/pluginManager.d.ts

@@ -16,7 +16,7 @@ export declare const sortPluginsByEnforce: (plugins: PluginMeta[]) => PluginMeta
  * execution order.
  */
 export declare const sortPluginsByDependencies: (plugins: PluginMeta[]) => PluginMeta[];
-export declare function initPlugins({ context, pluginManager, }: {
+export declare function initPlugins({ context, pluginManager }: {
     context: InternalContext;
     pluginManager: PluginManager;
 }): Promise<void>;

package/dist-types/restart.d.ts

@@ -11,7 +11,7 @@ export declare const restartDevServer: ({ filePath, clear, logger, }: {
     clear?: boolean;
     logger: Logger;
 }) => Promise<boolean>;
-export declare function watchFilesForRestart({ files, rsbuild, isBuildWatch, watchOptions, }: {
+export declare function watchFilesForRestart({ files, rsbuild, isBuildWatch, watchOptions }: {
     files: string[];
     rsbuild: RsbuildInstance;
     isBuildWatch: boolean;

package/dist-types/rspack-plugins/resource-hints/doesChunkBelongToHtml.d.ts

@@ -24,5 +24,5 @@ interface DoesChunkBelongToHtmlOptions {
     pluginOptions?: ResourceHintsOptions;
 }
 export declare function recursiveChunkEntryNames(chunk: Chunk): string[];
-export declare function doesChunkBelongToHtml({ chunk, htmlPluginData, }: DoesChunkBelongToHtmlOptions): boolean;
+export declare function doesChunkBelongToHtml({ chunk, htmlPluginData }: DoesChunkBelongToHtmlOptions): boolean;
 export {};

package/dist-types/rspack-plugins/resource-hints/getResourceType.d.ts

@@ -16,7 +16,7 @@
  * limitations under the License.
  */
 export type ResourceType = 'audio' | 'document' | 'embed' | 'fetch' | 'font' | 'image' | 'object' | 'script' | 'style' | 'track' | 'worker' | 'video';
-export declare function getResourceType({ href, file, }: {
+export declare function getResourceType({ href, file }: {
     href: string;
     file: string;
 }): ResourceType;

package/dist-types/rspackConfig.d.ts

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

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

@@ -2,7 +2,7 @@ import type { Logger } from '../logger';
 import type { CliShortcut, NormalizedConfig } from '../types/config';
 export declare const isCliShortcutsEnabled: (config: NormalizedConfig) => boolean;
 export declare const normalizeShortcutInput: (input: string) => string;
-export declare function setupCliShortcuts({ help, openPage, closeServer, printUrls, restartServer, customShortcuts, logger, }: {
+export declare function setupCliShortcuts({ help, openPage, closeServer, printUrls, restartServer, customShortcuts, logger }: {
     help?: boolean | string;
     openPage: () => Promise<void>;
     closeServer: () => Promise<void>;

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

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

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

@@ -30,7 +30,7 @@ export declare const joinUrlSegments: (s1: string, s2: string) => string;
 export declare const stripBase: (path: string, base: string) => string;
 export declare const getRoutes: (context: InternalContext) => Routes;
 export declare const formatRoutes: (entry: RsbuildEntry, base: string, distPathPrefix: string | undefined, outputStructure: OutputStructure | undefined) => Routes;
-export declare function printServerURLs({ urls: originalUrls, port, routes, protocol, printUrls, trailingLineBreak, originalConfig, logger, }: {
+export declare function printServerURLs({ urls: originalUrls, port, routes, protocol, printUrls, fallbackPathname, trailingLineBreak, originalConfig, logger }: {
     urls: {
         url: string;
         label: string;
@@ -39,6 +39,7 @@ export declare function printServerURLs({ urls: originalUrls, port, routes, prot
     routes: Routes;
     protocol: string;
     printUrls?: PrintUrls;
+    fallbackPathname?: string;
     trailingLineBreak?: boolean;
     originalConfig?: Readonly<RsbuildConfig>;
     logger: Logger;

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

@@ -2,7 +2,7 @@ import type { Logger } from '../logger';
 import type { NormalizedConfig, Routes } from '../types';
 export declare const replacePortPlaceholder: (url: string, port: number) => string;
 export declare function resolveUrl(str: string, base: string): string;
-export declare function open({ port, routes, config, protocol, clearCache, logger, }: {
+export declare function open({ port, routes, config, protocol, clearCache, logger }: {
     port: number;
     routes: Routes;
     config: NormalizedConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "The Rspack-based build tool.",
   "homepage": "https://rsbuild.rs",
   "bugs": {
@@ -50,7 +50,7 @@
   "devDependencies": {
     "@jridgewell/remapping": "^2.3.5",
     "@jridgewell/trace-mapping": "^0.3.31",
-    "@rslib/core": "0.21.2",
+    "@rslib/core": "0.21.3",
     "@types/cors": "^2.8.19",
     "@types/node": "^24.12.2",
     "@types/on-finished": "2.3.5",
@@ -65,7 +65,7 @@
     "deepmerge": "^4.3.1",
     "dotenv-expand": "13.0.0",
     "html-rspack-plugin": "6.1.8",
-    "http-proxy-middleware": "4.0.0-beta.3",
+    "http-proxy-middleware": "4.0.0-beta.4",
     "jiti": "^2.6.1",
     "launch-editor-middleware": "^2.13.2",
     "memfs": "^4.57.2",