@rsbuild/core 2.1.2 → 2.1.3

package/dist/756.js

@@ -3500,7 +3500,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.1.2",
+        version: "2.1.3",
         rootPath,
         distPath: '',
         cachePath,
@@ -3778,12 +3778,15 @@ let configChain_CHAIN_ID = {
         JS_MAIN: 'js',
         JS_WORKER: 'js-worker',
         JS_RAW: 'js-raw',
+        JS_TEXT: 'js-text',
         CSS_MAIN: 'css',
         CSS_RAW: 'css-raw',
+        CSS_TEXT: 'css-text',
         CSS_URL: 'css-url',
         CSS_INLINE: 'css-inline',
         SVG: 'svg',
         SVG_RAW: 'svg-asset-raw',
+        SVG_TEXT: 'svg-asset-text',
         SVG_URL: 'svg-asset-url',
         SVG_ASSET: 'svg-asset',
         SVG_REACT: 'svg-react',
@@ -4817,7 +4820,9 @@ let chainStaticAssetRule = ({ emit, rule, maxSize, filename, assetType })=>{
     let generatorOptions = {
         filename
     };
-    emit || (generatorOptions.emit = !1), rule.oneOf(`${assetType}-asset-url`).type('asset/resource').resourceQuery(URL_QUERY_REGEX).set('generator', generatorOptions), rule.oneOf(`${assetType}-asset-inline`).type('asset/inline').resourceQuery(INLINE_QUERY_REGEX), rule.oneOf(`${assetType}-asset-raw`).type('asset/source').resourceQuery(RAW_QUERY_REGEX), rule.oneOf(`${assetType}-asset`).type('asset').parser({
+    emit || (generatorOptions.emit = !1), rule.oneOf(`${assetType}-asset-url`).type('asset/resource').resourceQuery(URL_QUERY_REGEX).set('generator', generatorOptions), rule.oneOf(`${assetType}-asset-inline`).type('asset/inline').resourceQuery(INLINE_QUERY_REGEX), rule.oneOf(`${assetType}-asset-text`).type('asset/source').with({
+        type: 'text'
+    }), rule.oneOf(`${assetType}-asset-raw`).type('asset/source').resourceQuery(RAW_QUERY_REGEX), rule.oneOf(`${assetType}-asset`).type('asset').parser({
         dataUrlCondition: {
             maxSize
         }
@@ -5150,7 +5155,7 @@ async function saveSnapshots(snapshotPath, snapshots, logger) {
         logger.debug('Failed to save file size snapshots:', err);
     }
 }
-let EXCLUDE_ASSET_REGEX = /\.(?:map|LICENSE\.txt|d\.ts)$/, isSignificantDiff = (diff)=>Math.abs(diff) >= 10, formatDiff = (diff)=>{
+let EXCLUDE_ASSET_REGEX = /\.(?:map|LICENSE\.txt|d\.(?:ts|mts|cts))$/, isSignificantDiff = (diff)=>Math.abs(diff) >= 10, formatDiff = (diff)=>{
     let label = `(${diff > 0 ? '+' : '-'}${calcFileSize(Math.abs(diff))})`;
     return {
         label: (diff > 0 ? color.red : color.green)(label),
@@ -5175,7 +5180,7 @@ function getHeader(maxFileLength, maxSizeLength, fileHeader, showGzipHeader) {
 let calcFileSize = (len)=>{
     let val = len / 1000;
     return `${val.toFixed(val < 1 ? 2 : 1)} kB`;
-}, COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest|md)$/i, isCompressible = (assetName)=>COMPRESSIBLE_REGEX.test(assetName), getFilePath = (assetName)=>{
+}, COMPRESSIBLE_REGEX = /\.(?:js|mjs|cjs|jsx|ts|tsx|mts|cts|css|html|json|svg|txt|xml|xhtml|wasm|manifest|md)$/i, isCompressible = (assetName)=>COMPRESSIBLE_REGEX.test(assetName), getFilePath = (assetName)=>{
     let queryIndex = assetName.indexOf('?');
     return -1 === queryIndex ? assetName : assetName.slice(0, queryIndex);
 };
@@ -5823,7 +5828,8 @@ let supportedChromiumBrowsers = [
     'Microsoft Edge',
     'Brave Browser',
     'Vivaldi',
-    'Chromium'
+    'Chromium',
+    'Helium'
 ], mapChromiumBrowserName = (browser)=>'chrome' === browser || 'google chrome' === browser ? 'Google Chrome' : browser;
 async function openBrowser(url, logger) {
     let browser = process.env.BROWSER, browserArgs = process.env.BROWSER_ARGS;
@@ -8736,7 +8742,11 @@ function applyDefaultPlugins(pluginManager, context) {
                     ], emitAssets), createAssetRule(configChain_CHAIN_ID.RULE.MEDIA, [
                         ...VIDEO_EXTENSIONS,
                         ...AUDIO_EXTENSIONS
-                    ], emitAssets), createAssetRule(configChain_CHAIN_ID.RULE.FONT, FONT_EXTENSIONS, emitAssets), chain.module.rule(configChain_CHAIN_ID.RULE.JSON).test(/\.json$/i).oneOf('json-asset-raw').type('asset/source').resourceQuery(RAW_QUERY_REGEX);
+                    ], emitAssets), createAssetRule(configChain_CHAIN_ID.RULE.FONT, FONT_EXTENSIONS, emitAssets);
+                    let rule = chain.module.rule(configChain_CHAIN_ID.RULE.JSON).test(/\.json$/i);
+                    rule.oneOf('json-asset-text').type('asset/source').with({
+                        type: 'text'
+                    }), rule.oneOf('json-asset-raw').type('asset/source').resourceQuery(RAW_QUERY_REGEX);
                     let assetsFilename = getMergedFilename('assets');
                     chain.output.assetModuleFilename(assetsFilename), emitAssets || chain.module.generator.merge({
                         'asset/resource': {
@@ -9034,7 +9044,9 @@ try {
                         let cssRule = chain.module.rule(CHAIN_ID.RULE.CSS), { config } = environment;
                         cssRule.test(CSS_REGEX).dependency({
                             not: 'url'
-                        });
+                        }), cssRule.oneOf(CHAIN_ID.ONE_OF.CSS_TEXT).with({
+                            type: 'text'
+                        }).type('asset/source');
                         let urlRule = cssRule.oneOf(CHAIN_ID.ONE_OF.CSS_URL).resourceQuery(URL_QUERY_REGEX);
                         urlRule.use(CHAIN_ID.USE.CSS_URL).loader(node_path.join(dirname, 'cssUrlLoader.mjs'));
                         let inlineRule = cssRule.oneOf(CHAIN_ID.ONE_OF.CSS_INLINE).resourceQuery(INLINE_QUERY_REGEX);
@@ -9194,7 +9206,9 @@ try {
                         let { config, browserslist } = environment, cacheRoot = node_path.join(api.context.cachePath, '.swc'), rule = chain.module.rule(CHAIN_ID.RULE.JS).test(SCRIPT_REGEX).dependency({
                             not: 'url'
                         });
-                        rule.oneOf(CHAIN_ID.ONE_OF.JS_RAW).resourceQuery(RAW_QUERY_REGEX).type('asset/source');
+                        rule.oneOf(CHAIN_ID.ONE_OF.JS_TEXT).with({
+                            type: 'text'
+                        }).type('asset/source'), rule.oneOf(CHAIN_ID.ONE_OF.JS_RAW).resourceQuery(RAW_QUERY_REGEX).type('asset/source');
                         let mainRule = rule.oneOf(CHAIN_ID.ONE_OF.JS_MAIN).type("javascript/auto"), dataUriRule = chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
                             or: [
                                 "text/javascript",
@@ -9853,36 +9867,53 @@ async function createRsbuild(options = {}) {
 function defineConfig(config) {
     return config;
 }
-async function loadConfig_loadConfig({ cwd = process.cwd(), path, envMode, meta, loader = 'auto' } = {}) {
-    let configExport, configFilePath = ((root, customConfig)=>{
+let DEFAULT_CONFIG_FILE_NAMES = [
+    'rsbuild.config.ts',
+    'rsbuild.config.js',
+    'rsbuild.config.mts',
+    'rsbuild.config.mjs',
+    'rsbuild.config.cts',
+    'rsbuild.config.cjs'
+], getConfigExport = (module)=>module && 'object' == typeof module && 'default' in module ? module.default : module, tryFreshImport = async (configFileURL)=>{
+    try {
+        let { freshImport } = await import("./fresh-import.js");
+        return await freshImport(configFileURL);
+    } catch (err) {
+        src_logger.debug('failed to initialize fresh-import, fallback to dynamic import.'), src_logger.debug(err);
+    }
+}, loadConfigWithNative = async (configFilePath)=>{
+    let configFileURL = pathToFileURL(configFilePath).href, freshImportResult = await tryFreshImport(configFileURL);
+    return freshImportResult ? {
+        configExport: getConfigExport(freshImportResult.result),
+        dependencies: freshImportResult.dependencies.sort()
+    } : {
+        configExport: getConfigExport(await import(`${configFileURL}?t=${Date.now()}`)),
+        dependencies: []
+    };
+};
+async function loadConfig_loadConfig({ cwd = process.cwd(), path, configFileNames, envMode, meta, loader = 'auto', command } = {}) {
+    let configExport, configFilePath = ((root, customConfig, configFileNames = DEFAULT_CONFIG_FILE_NAMES)=>{
         if (customConfig) {
             let customConfigPath = external_node_path_isAbsolute(customConfig) ? customConfig : join(root, customConfig);
             if (node_fs.existsSync(customConfigPath)) return customConfigPath;
             throw Error(`Cannot find config file: ${color.dim(customConfigPath)}`);
         }
-        for (let file of [
-            'rsbuild.config.ts',
-            'rsbuild.config.js',
-            'rsbuild.config.mts',
-            'rsbuild.config.mjs',
-            'rsbuild.config.cts',
-            'rsbuild.config.cjs'
-        ]){
+        for (let file of configFileNames){
             let configFile = join(root, file);
             if (node_fs.existsSync(configFile)) return configFile;
         }
         return null;
-    })(cwd, path);
+    })(cwd, path, configFileNames);
     if (!configFilePath) return src_logger.debug('no config file found.'), {
         content: {},
-        filePath: configFilePath
+        filePath: configFilePath,
+        dependencies: []
     };
-    let applyMetaInfo = (config)=>(config._privateMeta = {
+    let dependencies = [], applyMetaInfo = (config)=>(config._privateMeta = {
             configFilePath
         }, config);
     if ('native' === loader || 'auto' === loader && (process.features.typescript || process.versions.bun || process.versions.deno) || /\.(?:js|mjs|cjs)$/.test(configFilePath)) try {
-        let configFileURL = pathToFileURL(configFilePath).href, exportModule = await import(`${configFileURL}?t=${Date.now()}`);
-        configExport = exportModule.default ? exportModule.default : exportModule;
+        ({ configExport, dependencies } = await loadConfigWithNative(configFilePath));
     } catch (err) {
         let errorMessage = `Failed to load file with native loader: ${color.dim(configFilePath)}`;
         if ('native' === loader) throw src_logger.error(errorMessage), err;
@@ -9903,66 +9934,75 @@ async function loadConfig_loadConfig({ cwd = process.cwd(), path, envMode, meta,
         throw src_logger.error(`Failed to load file with jiti: ${color.dim(configFilePath)}`), err;
     }
     if ('function' == typeof configExport) {
-        let command = process.argv[2], nodeEnv = process.env.NODE_ENV || '', result = await configExport({
+        let nodeEnv = process.env.NODE_ENV || '', configParams = {
             env: nodeEnv,
-            command,
+            command: command ?? process.argv[2],
             envMode: envMode || nodeEnv,
             meta
-        });
+        }, result = await configExport(configParams);
         if (void 0 === result) throw Error(`${color.dim('[rsbuild:loadConfig]')} The config function must return a config object.`);
         return {
             content: applyMetaInfo(result),
-            filePath: configFilePath
+            filePath: configFilePath,
+            dependencies
         };
     }
     if (!isObject(configExport)) throw Error(`${color.dim('[rsbuild:loadConfig]')} The config must be an object or a function that returns an object, get ${color.yellow(configExport)}`);
     return src_logger.debug('configuration loaded from:', configFilePath), {
         content: applyMetaInfo(configExport),
-        filePath: configFilePath
+        filePath: configFilePath,
+        dependencies
     };
 }
-let commonOpts = {}, init_loadConfig = async (root)=>{
-    let { content: config, filePath } = await loadConfig_loadConfig({
+let cliState = {
+    options: {}
+}, initCliAction = (command, options)=>{
+    process.env.NODE_ENV || (process.env.NODE_ENV = 'build' === command || 'preview' === command ? 'production' : 'development'), options.environment?.some((env)=>env.includes(',')) && (options.environment = options.environment.flatMap((env)=>env.split(','))), cliState.command = command, cliState.options = options;
+}, init_loadConfig = async (root)=>{
+    let { options, command } = cliState, { content: config, filePath, dependencies } = await loadConfig_loadConfig({
         cwd: root,
-        path: commonOpts.config,
-        envMode: commonOpts.envMode,
-        loader: commonOpts.configLoader
+        path: options.config,
+        envMode: options.envMode,
+        loader: options.configLoader,
+        command
     });
-    if (config.dev ||= {}, config.source ||= {}, config.server ||= {}, commonOpts.base && (config.server.base = commonOpts.base), commonOpts.root && (config.root = root), commonOpts.mode && (config.mode = commonOpts.mode), commonOpts.logLevel && (config.logLevel = commonOpts.logLevel), commonOpts.open && !config.server?.open && (config.server.open = commonOpts.open), void 0 !== commonOpts.host && (config.server.host = commonOpts.host), commonOpts.port && (config.server.port = commonOpts.port), void 0 !== commonOpts.distPath) {
+    if (config.dev ||= {}, config.source ||= {}, config.server ||= {}, options.base && (config.server.base = options.base), options.root && (config.root = root), options.mode && (config.mode = options.mode), options.logLevel && (config.logLevel = options.logLevel), options.open && !config.server?.open && (config.server.open = options.open), void 0 !== options.host && (config.server.host = options.host), options.port && (config.server.port = options.port), void 0 !== options.strictPort && (config.server.strictPort = options.strictPort), void 0 !== options.distPath) {
         config.output ||= {};
         let { distPath } = config.output;
         config.output.distPath = distPath && 'object' == typeof distPath ? {
             ...distPath,
-            root: commonOpts.distPath
+            root: options.distPath
         } : {
-            root: commonOpts.distPath
+            root: options.distPath
         };
     }
-    if (void 0 !== commonOpts.sourceMap) {
-        let sourceMap = commonOpts.sourceMap;
+    if (void 0 !== options.sourceMap) {
+        let sourceMap = options.sourceMap;
         if ('boolean' != typeof sourceMap) throw Error('The "--source-map" option only accepts a boolean value.');
         config.output ||= {}, config.output.sourceMap = sourceMap;
     }
     return void 0 === config.dev.cliShortcuts && (config.dev.cliShortcuts = !0), filePath && (config.dev.watchFiles = [
         ...config.dev.watchFiles ? helpers_castArray(config.dev.watchFiles) : [],
         {
-            paths: filePath,
+            paths: [
+                filePath,
+                ...dependencies
+            ],
             type: 'reload-server'
         }
     ]), config;
 };
-async function init_init({ cliOptions, isRestart, isBuildWatch = !1 }) {
-    cliOptions && (commonOpts = cliOptions), commonOpts.environment?.some((env)=>env.includes(',')) && (commonOpts.environment = commonOpts.environment.flatMap((env)=>env.split(',')));
-    let logger = src_logger;
+async function init_init({ isRestart, isBuildWatch = !1 } = {}) {
+    let logger = src_logger, { options } = cliState;
     try {
         var envDir;
-        let cwd = process.cwd(), root = commonOpts.root ? ensureAbsolutePath(cwd, commonOpts.root) : cwd, rsbuild = await createRsbuild({
+        let cwd = process.cwd(), root = options.root ? ensureAbsolutePath(cwd, options.root) : cwd, rsbuild = await createRsbuild({
             cwd: root,
             config: ()=>init_loadConfig(root),
-            environment: commonOpts.environment,
-            loadEnv: !1 !== commonOpts.env && {
-                cwd: (envDir = commonOpts.envDir) ? node_path.isAbsolute(envDir) ? envDir : node_path.join(root, envDir) : root,
-                mode: commonOpts.envMode
+            environment: options.environment,
+            loadEnv: !1 !== options.env && {
+                cwd: (envDir = options.envDir) ? node_path.isAbsolute(envDir) ? envDir : node_path.join(root, envDir) : root,
+                mode: options.envMode
             }
         });
         return logger = rsbuild.logger, rsbuild.onBeforeCreateCompiler(()=>{
@@ -10042,11 +10082,11 @@ async function watchFilesForRestart({ files, rsbuild, isBuildWatch, watchOptions
     watcher.on('add', onChange), watcher.on('change', onChange), watcher.on('unlink', onChange);
 }
 let applyServerOptions = (command)=>{
-    command.option('-o, --open [url]', 'Open the page in browser on startup').option('--port <port>', 'Set the port number for the server').option('--host [host]', 'Set the host that the server listens to');
+    command.option('-o, --open [url]', 'Open the page in browser on startup').option('--port <port>', 'Set the port number for the server').option('--strict-port', 'Exit if the specified port is already in use').option('--host [host]', 'Set the host that the server listens to');
 };
-function setupCommands() {
+function setupCommands(argv) {
     let cli = ((name = "")=>new CAC(name))('rsbuild');
-    cli.version("2.1.2"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
+    cli.version("2.1.3"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (auto | jiti | native)', {
         default: 'auto'
     }).option('--dist-path <dir>', 'Set the root directory of output files').option('--source-map', 'Enable source map').option('--env-dir <dir>', 'Set the directory for loading `.env` files').option('--env-mode <mode>', 'Set the env mode to load the `.env.[mode]` file').option('--environment <name>', 'Set the environment name(s) to build', {
         type: [
@@ -10058,20 +10098,19 @@ function setupCommands() {
     applyServerOptions(devCommand), applyServerOptions(previewCommand);
     let logger = src_logger;
     devCommand.action(async (options)=>{
+        initCliAction('dev', options);
         try {
-            let rsbuild = await init_init({
-                cliOptions: options
-            });
+            let rsbuild = await init_init();
             if (!rsbuild) return;
             logger = rsbuild.logger, await rsbuild.startDevServer();
         } catch (err) {
             logger.error('Failed to start dev server.'), logger.error(err), process.exit(1);
         }
     }), buildCommand.option('-w, --watch', 'Enable watch mode to automatically rebuild on file changes').action(async (options)=>{
+        initCliAction('build', options);
         try {
             options.watch || (process.env.RSPACK_UNSAFE_FAST_DROP = 'true');
             let rsbuild = await init_init({
-                cliOptions: options,
                 isBuildWatch: options.watch
             });
             if (!rsbuild) return;
@@ -10084,20 +10123,18 @@ function setupCommands() {
             err instanceof Error && err.message === RSPACK_BUILD_ERROR || logger.error('Failed to build.'), logger.error(err), process.exit(1);
         }
     }), previewCommand.action(async (options)=>{
+        initCliAction('preview', options);
         try {
-            let rsbuild = await init_init({
-                cliOptions: options
-            });
+            let rsbuild = await init_init();
             if (!rsbuild) return;
             logger = rsbuild.logger, await rsbuild.preview();
         } catch (err) {
             logger.error('Failed to start preview server.'), logger.error(err), process.exit(1);
         }
     }), inspectCommand.option('--output <output>', 'Set the output path for inspection results').option('--verbose', 'Show complete function definitions in output').action(async (options)=>{
+        initCliAction('inspect', options);
         try {
-            let rsbuild = await init_init({
-                cliOptions: options
-            });
+            let rsbuild = await init_init();
             if (!rsbuild) return;
             logger = rsbuild.logger, await rsbuild.inspectConfig({
                 verbose: options.verbose,
@@ -10109,21 +10146,17 @@ function setupCommands() {
         }
     }), cli.help((sections)=>{
         for (let section of (sections.shift(), sections))'Usage' === section.title && (section.body = section.body.replace('$ rsbuild', color.yellow("$ rsbuild [command] [options]"))), 'Commands' === section.title && (section.body = section.body.replace(`         ${devDescription}`, `dev      ${devDescription}`)), section.title?.startsWith('For more info') ? (section.title = color.dim('  For details on a sub-command, run'), section.body = color.dim('  $ rsbuild <command> -h')) : section.title && (section.title = color.cyan(section.title));
-    }), cli.parse();
-}
-let { argv: cli_argv } = process;
-function initNodeEnv(command) {
-    process.env.NODE_ENV || (process.env.NODE_ENV = 'build' === command || 'preview' === command ? 'production' : 'development');
+    }), cli.parse(argv);
 }
 function showGreeting() {
     let { npm_execpath, npm_lifecycle_event, NODE_RUN_SCRIPT_NAME } = process.env, isBun = npm_execpath?.includes('.bun');
-    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.1.2\n`);
+    src_logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}Rsbuild v2.1.3\n`);
 }
-function setupLogLevel() {
-    if (cli_argv.length <= 3) return;
-    let logLevelIndex = cli_argv.findIndex((item)=>'--log-level' === item || '--logLevel' === item);
+function setupLogLevel(argv) {
+    if (argv.length <= 3) return;
+    let logLevelIndex = argv.findIndex((item)=>'--log-level' === item || '--logLevel' === item);
     if (-1 !== logLevelIndex) {
-        let level = process.argv[logLevelIndex + 1];
+        let level = argv[logLevelIndex + 1];
         level && [
             'warn',
             'error',
@@ -10131,13 +10164,13 @@ function setupLogLevel() {
         ].includes(level) && !isDebug() && (src_logger.level = level);
     }
 }
-function runCLI() {
-    initNodeEnv(cli_argv[2]), setupLogLevel(), showGreeting();
+function runCLI({ argv = process.argv } = {}) {
+    setupLogLevel(argv), showGreeting();
     try {
-        setupCommands();
+        setupCommands(argv);
     } catch (err) {
         src_logger.error('Failed to start Rsbuild CLI.'), src_logger.error(err), process.exit(1);
     }
 }
-let src_version = "2.1.2";
+let src_version = "2.1.3";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, core_rspack as rspack, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger_createLogger as createLogger, mergeRsbuildConfig, mrmime_lookup, runCLI, src_logger as logger, src_version as version };

package/dist/fresh-import.js

@@ -0,0 +1,90 @@
+let importer;
+import { Module } from "node:module";
+import { fileURLToPath } from "node:url";
+import { MessageChannel } from "node:worker_threads";
+let instanceId = Math.random().toString(36).slice(2), relativeImportRE = /^\.{1,2}(?:\/|\\)/;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildQueryName() {
+    return `fresh-import-${instanceId}`;
+}
+function buildQueryRE(queryName) {
+    return RegExp(`(?:\\?|&)${escapeRegExp(queryName)}=(\\d+),([^&]+)(?:&|$)`);
+}
+function formatTrackingQuery(queryName, id, context) {
+    return `?${queryName}=${id},${context}`;
+}
+function trackResolved(specifier, context, result, queryName, queryRE, onDependency) {
+    let isRelativeImport = relativeImportRE.test(specifier);
+    if ("builtin" === result.format || !isRelativeImport || !context.parentURL || queryRE.test(result.url) || !result.url.startsWith("file:")) return result;
+    let m = queryRE.exec(context.parentURL);
+    if (m) {
+        let [, id, contextFile] = m;
+        onDependency(contextFile, result.url), result.url = result.url.replace(/(\?)|$/, (_n, n1)=>`?${queryName}=${id},${contextFile}${"?" === n1 ? "&" : ""}`);
+    }
+    return result;
+}
+let nextId$1 = 0;
+function createOffThreadImporter() {
+    let queryName = buildQueryName(), { port1, port2 } = new MessageChannel();
+    return Module.register('data:text/javascript,Math.random().toString(36).slice(2);%0Aconst relativeImportRE = /^\\.{1,2}(%3F:\\/|\\\\)/;%0Afunction escapeRegExp(value) {%0A%09return value.replace(/[.*+%3F^${}()|[\\]\\\\]/g, "\\\\$&");%0A}%0A/**%0A* Build the regex that matches the tracking query `%3F<name>=<id>,<context>`%0A* (or the `&<name>=...` form).%0A*/%0Afunction buildQueryRE(queryName) {%0A%09return new RegExp(`(%3F:\\\\%3F|&)${escapeRegExp(queryName)}=(\\\\d+),([^&]+)(%3F:&|$)`);%0A}%0A/**%0A* Shared body of the resolve hook for both the on-thread and off-thread%0A* importers. Given an already-resolved `result`, decides whether it is a tracked%0A* relative file dependency; if so, reports it via `onDependency` and tags the%0A* URL so the query propagates to its own dependencies.%0A*%0A* The sync/async difference between the two hooks lives entirely in the caller%0A* (which awaits `nextResolve` or not); this function performs no I/O. `result`%0A* is mutated in place and returned.%0A*/%0Afunction trackResolved(specifier, context, result, queryName, queryRE, onDependency) {%0A%09const isRelativeImport = relativeImportRE.test(specifier);%0A%09if (result.format === "builtin" || !isRelativeImport) return result;%0A%09if (!context.parentURL || queryRE.test(result.url) || !result.url.startsWith("file:")) return result;%0A%09const m = queryRE.exec(context.parentURL);%0A%09if (m) {%0A%09%09const [, id, contextFile] = m;%0A%09%09onDependency(contextFile, result.url);%0A%09%09result.url = result.url.replace(/(\\%3F)|$/, (_n, n1) => `%3F${queryName}=${id},${contextFile}${n1 === "%3F" %3F "&" : ""}`);%0A%09}%0A%09return result;%0A}%0A//%23endregion%0A//%23region src/off-thread/loader.ts%0Alet port;%0Alet queryName;%0Alet queryRE;%0Aconst initialize = async (data) => {%0A%09port = data.port;%0A%09queryName = data.queryName;%0A%09queryRE = buildQueryRE(queryName);%0A};%0Aconst resolve = async (specifier, context, nextResolve) => {%0A%09return trackResolved(specifier, context, await nextResolve(specifier, context), queryName, queryRE, (ctx, url) => {%0A%09%09port.postMessage({%0A%09%09%09context: ctx,%0A%09%09%09url%0A%09%09});%0A%09});%0A};%0A//%23endregion%0Aexport { initialize, resolve };%0A', {
+        data: {
+            port: port2,
+            queryName
+        },
+        transferList: [
+            port2
+        ]
+    }), port1.unref(), {
+        async collect (specifier) {
+            let id = nextId$1++, depsList = new Set(), onMessage = (e)=>{
+                e.context === specifier && depsList.add(e.url);
+            };
+            port1.on("message", onMessage), port1.unref();
+            try {
+                let result = await import(specifier + formatTrackingQuery(queryName, id, specifier));
+                return await new Promise((resolve)=>setImmediate(resolve)), {
+                    result,
+                    dependencies: [
+                        ...depsList
+                    ].filter((url)=>url.startsWith("file:")).map((url)=>fileURLToPath(url))
+                };
+            } finally{
+                port1.off("message", onMessage);
+            }
+        }
+    };
+}
+let nextId = 0;
+function createOnThreadImporter() {
+    let registry = new Map(), queryName = buildQueryName(), queryRE = buildQueryRE(queryName);
+    return Module.registerHooks({
+        resolve: (specifier, context, nextResolve)=>trackResolved(specifier, context, nextResolve(specifier, context), queryName, queryRE, (ctx, url)=>{
+                registry.get(ctx)?.add(url);
+            })
+    }), {
+        async collect (specifier) {
+            let id = nextId++, depsList = new Set();
+            registry.set(specifier, depsList);
+            try {
+                return {
+                    result: await import(specifier + formatTrackingQuery(queryName, id, specifier)),
+                    dependencies: [
+                        ...depsList
+                    ].filter((url)=>url.startsWith("file:")).map((url)=>fileURLToPath(url))
+                };
+            } finally{
+                registry.delete(specifier);
+            }
+        }
+    };
+}
+function createImporter() {
+    return Module.registerHooks ? createOnThreadImporter() : Module.register ? createOffThreadImporter() : void 0;
+}
+let initialized = !1;
+function freshImport(specifier) {
+    return initialized || (importer = createImporter(), initialized = !0), importer?.collect(specifier);
+}
+export { freshImport };

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

@@ -14,6 +14,7 @@ export type CommonOptions = {
     open?: boolean | string;
     host?: true | string;
     port?: number;
+    strictPort?: boolean;
     environment?: string[];
     logLevel?: LogLevel;
 };
@@ -27,4 +28,4 @@ export type InspectOptions = CommonOptions & {
 };
 export type DevOptions = CommonOptions;
 export type PreviewOptions = CommonOptions;
-export declare function setupCommands(): void;
+export declare function setupCommands(argv: string[]): void;

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

@@ -1 +1,7 @@
-export declare function runCLI(): void;
+export type RunCLIOptions = {
+    /**
+   * The command-line arguments to parse, matching the shape of Node.js `process.argv`
+   * @default process.argv
+   */ argv?: string[];
+};
+export declare function runCLI({ argv }?: RunCLIOptions): void;

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

@@ -1,7 +1,8 @@
 import type { RsbuildInstance } from '../types';
 import type { CommonOptions } from './commands';
-export declare function init({ cliOptions, isRestart, isBuildWatch }: {
-    cliOptions?: CommonOptions;
+export type CommandName = 'dev' | 'build' | 'preview' | 'inspect';
+export declare const initCliAction: (command: CommandName, options: CommonOptions) => void;
+export declare function init({ isRestart, isBuildWatch }?: {
     isRestart?: boolean;
     isBuildWatch?: boolean;
 }): Promise<RsbuildInstance | undefined>;

package/dist-types/configChain.d.ts

@@ -24,12 +24,15 @@ export declare const CHAIN_ID: {
         /** JS oneOf rules */ readonly JS_MAIN: 'js';
         readonly JS_WORKER: 'js-worker';
         readonly JS_RAW: 'js-raw';
+        readonly JS_TEXT: 'js-text';
         /** CSS oneOf rules */ readonly CSS_MAIN: 'css';
         readonly CSS_RAW: 'css-raw';
+        readonly CSS_TEXT: 'css-text';
         readonly CSS_URL: 'css-url';
         readonly CSS_INLINE: 'css-inline';
         /** SVG oneOf rules */ readonly SVG: 'svg';
         readonly SVG_RAW: 'svg-asset-raw';
+        readonly SVG_TEXT: 'svg-asset-text';
         readonly SVG_URL: 'svg-asset-url';
         readonly SVG_ASSET: 'svg-asset';
         readonly SVG_REACT: 'svg-react';

package/dist-types/index.d.ts

@@ -3,9 +3,9 @@
  * the public API of @rsbuild/core.
  */ import type * as Rspack from '@rspack/core';
 import { rspack } from '@rspack/core';
-export { runCLI } from './cli';
+export { type RunCLIOptions, runCLI } from './cli';
 export { createRsbuild } from './createRsbuild';
-export { type ConfigParams, defineConfig, type LoadConfigOptions, type LoadConfigResult, loadConfig } from './loadConfig';
+export { type ConfigParams, defineConfig, type LoadConfigOptions, type LoadConfigResult, type RsbuildConfigAsyncFn, type RsbuildConfigDefinition, type RsbuildConfigSyncFn, loadConfig } from './loadConfig';
 // Core methods
 export { type LoadEnvOptions, type LoadEnvResult, loadEnv } from './loadEnv';
 // Rsbuild version

package/dist-types/loadConfig.d.ts

@@ -7,7 +7,7 @@ export type ConfigParams = {
 };
 export type RsbuildConfigAsyncFn = (env: ConfigParams) => Promise<RsbuildConfig>;
 export type RsbuildConfigSyncFn = (env: ConfigParams) => RsbuildConfig;
-export type RsbuildConfigExport = RsbuildConfig | RsbuildConfigSyncFn | RsbuildConfigAsyncFn;
+export type RsbuildConfigDefinition = RsbuildConfig | RsbuildConfigSyncFn | RsbuildConfigAsyncFn;
 export type LoadConfigOptions = {
     /**
    * The root path to resolve the config file.
@@ -18,6 +18,10 @@ export type LoadConfigOptions = {
    * If `path` is not provided, the function will search for the config file in the `cwd`.
    */ path?: string;
     /**
+   * Config file names to search in `cwd` when `path` is not provided.
+   * The list replaces the default `rsbuild.config.*` lookup order.
+   */ configFileNames?: string[];
+    /**
    * A custom meta object to be passed into the config function of `defineConfig`.
    */ meta?: Record<string, unknown>;
     /**
@@ -31,6 +35,10 @@ export type LoadConfigOptions = {
    * - 'native': Use native Node.js loader, requires TypeScript support in Node.js >= 22.6
    * @default 'auto'
    */ loader?: ConfigLoader;
+    /**
+   * The command passed to the config function.
+   * @default process.argv[2]
+   */ command?: string;
 };
 export type LoadConfigResult = {
     /**
@@ -40,6 +48,10 @@ export type LoadConfigResult = {
    * The path to the loaded configuration file.
    * Return `null` if the configuration file is not found.
    */ filePath: string | null;
+    /**
+   * Absolute file paths of statically imported (relative) dependencies of the
+   * config file.
+   */ dependencies: string[];
 };
 /**
  * This function helps you to autocomplete configuration types.
@@ -47,6 +59,6 @@ export type LoadConfigResult = {
  */ export declare function defineConfig(config: RsbuildConfig): RsbuildConfig;
 export declare function defineConfig(config: RsbuildConfigSyncFn): RsbuildConfigSyncFn;
 export declare function defineConfig(config: RsbuildConfigAsyncFn): RsbuildConfigAsyncFn;
-export declare function defineConfig(config: RsbuildConfigExport): RsbuildConfigExport;
+export declare function defineConfig(config: RsbuildConfigDefinition): RsbuildConfigDefinition;
 export type ConfigLoader = 'auto' | 'jiti' | 'native';
-export declare function loadConfig({ cwd, path, envMode, meta, loader }?: LoadConfigOptions): Promise<LoadConfigResult>;
+export declare function loadConfig({ cwd, path, configFileNames, envMode, meta, loader, command }?: LoadConfigOptions): Promise<LoadConfigResult>;

package/dist-types/plugins/fileSize.d.ts

@@ -3,5 +3,5 @@
  * license at https://github.com/facebook/create-react-app/blob/master/LICENSE
  */ import type { InternalContext, PrintFileSizeAsset, RsbuildPlugin } from '../types';
 /** Normalize file path by removing hash for comparison across builds */ export declare function normalizeFilePath(filePath: string): string;
-/** Exclude source map and license files by default */ export declare const excludeAsset: (asset: PrintFileSizeAsset) => boolean;
+/** Exclude source map, license, and type declaration files by default */ export declare const excludeAsset: (asset: PrintFileSizeAsset) => boolean;
 export declare const pluginFileSize: (context: InternalContext) => RsbuildPlugin;

package/dist-types/types/config.d.ts

@@ -516,7 +516,7 @@ export type PrintFileSizeOptions = {
     /**
    * A filter function to exclude static assets from the total size or detailed size.
    * If both `include` and `exclude` are set, `exclude` will take precedence.
-   * @default (asset) => /\.(?:map|LICENSE\.txt)$/.test(asset.name)
+   * @default (asset) => /\.(?:map|LICENSE\.txt|d\.(?:ts|mts|cts))$/.test(asset.name)
    */ exclude?: (asset: PrintFileSizeAsset) => boolean;
     /**
    * Controls whether file size differences are displayed relative to the previous build.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/core",
-  "version": "2.1.2",
+  "version": "2.1.3",
   "description": "The Rspack-based build tool.",
   "homepage": "https://rsbuild.rs",
   "bugs": {
@@ -61,6 +61,7 @@
     "css-loader": "7.1.4",
     "deepmerge": "^4.3.1",
     "dotenv-expand": "^13.0.0",
+    "fresh-import": "^0.2.1",
     "html-rspack-plugin": "6.1.9",
     "http-proxy-middleware": "4.1.1",
     "jiti": "^2.7.0",