@rstest/core 0.2.2 → 0.3.0

package/dist/985.js

@@ -7,37 +7,38 @@ export const __webpack_ids__ = [
 export const __webpack_modules__ = {
     "./src/core/rsbuild.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            X: ()=>createRsbuildServer,
-            z: ()=>prepareRsbuild
+            XD: ()=>createRsbuildServer,
+            zh: ()=>prepareRsbuild
         });
         var core_ = __webpack_require__("@rsbuild/core");
         var external_pathe_ = __webpack_require__("pathe");
         var utils = __webpack_require__("./src/utils/index.ts");
+        const RUNTIME_CHUNK_NAME = 'runtime';
         const pluginBasic = (context)=>({
                 name: 'rstest:basic',
                 setup: (api)=>{
-                    api.modifyRsbuildConfig(async (config)=>{
-                        config.environments = {
-                            [context.normalizedConfig.name]: {
-                                output: {
-                                    target: 'node'
-                                }
-                            }
-                        };
-                    });
-                    api.modifyEnvironmentConfig(async (config, { mergeEnvironmentConfig })=>mergeEnvironmentConfig(config, {
+                    api.modifyEnvironmentConfig(async (config, { mergeEnvironmentConfig, name })=>{
+                        const { normalizedConfig: { resolve, source, output, tools, performance, dev, testEnvironment }, rootPath } = context.projects.find((p)=>p.environmentName === name);
+                        return mergeEnvironmentConfig(config, {
+                            performance,
+                            tools,
+                            resolve,
+                            source,
+                            output,
+                            dev
+                        }, {
                             source: {
                                 define: {
                                     'import.meta.rstest': "global['@rstest/core']"
                                 }
                             },
                             output: {
-                                manifest: true,
+                                manifest: `${name}-manifest.json`,
                                 sourceMap: {
                                     js: 'source-map'
                                 },
                                 distPath: {
-                                    root: utils.zZ
+                                    root: context.projects.length > 1 ? `${utils.zZ}/${name}` : utils.zZ
                                 }
                             },
                             tools: {
@@ -51,7 +52,7 @@ export const __webpack_modules__ = {
                                         injectModulePathName: true,
                                         importMetaPathName: true,
                                         hoistMockModule: true,
-                                        manualMockRoot: external_pathe_["default"].resolve(context.rootPath, '__mocks__')
+                                        manualMockRoot: external_pathe_["default"].resolve(rootPath, '__mocks__')
                                     }));
                                     config.module.parser ??= {};
                                     config.module.parser.javascript = {
@@ -74,7 +75,7 @@ export const __webpack_modules__ = {
                                         '.jsx',
                                         '.tsx'
                                     ];
-                                    if ('node' === context.normalizedConfig.testEnvironment) config.resolve.mainFields = config.resolve.mainFields?.filter((filed)=>'module' !== filed) || [
+                                    if ('node' === testEnvironment) config.resolve.mainFields = config.resolve.mainFields?.filter((filed)=>'module' !== filed) || [
                                         'main'
                                     ];
                                     config.resolve.byDependency ??= {};
@@ -89,12 +90,13 @@ export const __webpack_modules__ = {
                                         nodeEnv: false,
                                         ...config.optimization || {},
                                         runtimeChunk: {
-                                            name: 'runtime'
+                                            name: `${name}-${RUNTIME_CHUNK_NAME}`
                                         }
                                     };
                                 }
                             }
-                        }));
+                        });
+                    });
                 }
             });
         var external_node_path_ = __webpack_require__("node:path");
@@ -142,31 +144,32 @@ export const __webpack_modules__ = {
                 });
             }
         }
-        const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles, configFilePath })=>({
+        const pluginEntryWatch = ({ isWatch, globTestSourceEntries, setupFiles, context })=>({
                 name: 'rstest:entry-watch',
                 setup: (api)=>{
-                    api.modifyRspackConfig(async (config)=>{
+                    api.modifyRspackConfig(async (config, { environment })=>{
                         if (isWatch) {
-                            config.plugins.push(new TestFileWatchPlugin(api.context.rootPath));
+                            config.plugins.push(new TestFileWatchPlugin(environment.config.root));
                             config.entry = async ()=>{
-                                const sourceEntries = await globTestSourceEntries();
+                                const sourceEntries = await globTestSourceEntries(environment.name);
                                 return {
                                     ...sourceEntries,
-                                    ...setupFiles
+                                    ...setupFiles[environment.name]
                                 };
                             };
                             config.watchOptions ??= {};
                             config.watchOptions.ignored = (0, utils.bg)(config.watchOptions.ignored || []);
                             if (0 === config.watchOptions.ignored.length) config.watchOptions.ignored.push('**/.git', '**/node_modules');
                             config.watchOptions.ignored.push(utils.EJ, '**/*.snap');
+                            const configFilePath = context.projects.find((project)=>project.environmentName === environment.name)?.configFilePath;
                             if (configFilePath) config.watchOptions.ignored.push(configFilePath);
                         } else {
                             config.watch = false;
                             config.watchOptions ??= {};
                             config.watchOptions.ignored = '**/**';
-                            const sourceEntries = await globTestSourceEntries();
+                            const sourceEntries = await globTestSourceEntries(environment.name);
                             config.entry = {
-                                ...setupFiles,
+                                ...setupFiles[environment.name],
                                 ...sourceEntries
                             };
                         }
@@ -196,10 +199,12 @@ export const __webpack_modules__ = {
             if (isNodeBuiltin) callback(void 0, request, 'commonjs' === dependencyType ? 'commonjs' : 'module-import');
             else callback();
         }
-        const pluginExternal = (testEnvironment)=>({
+        const pluginExternal = (context)=>({
                 name: 'rstest:external',
                 setup: (api)=>{
-                    api.modifyRsbuildConfig(async (config, { mergeRsbuildConfig })=>mergeRsbuildConfig(config, {
+                    api.modifyEnvironmentConfig(async (config, { mergeEnvironmentConfig, name })=>{
+                        const { normalizedConfig: { testEnvironment } } = context.projects.find((p)=>p.environmentName === name);
+                        return mergeEnvironmentConfig(config, {
                             output: {
                                 externals: 'node' === testEnvironment ? [
                                     autoExternalNodeModules
@@ -216,7 +221,8 @@ export const __webpack_modules__ = {
                                     config.externals.push(autoExternalNodeBuiltin);
                                 }
                             }
-                        }));
+                        });
+                    });
                 }
             });
         class IgnoreModuleNotFoundErrorPlugin {
@@ -444,17 +450,13 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
         }
         const isMultiCompiler = (compiler)=>'compilers' in compiler && Array.isArray(compiler.compilers);
         const prepareRsbuild = async (context, globTestSourceEntries, setupFiles)=>{
-            const { command, normalizedConfig: { isolate, plugins, resolve, source, output, tools, testEnvironment, performance, dev = {} } } = context;
+            const { command, normalizedConfig: { isolate, dev = {} } } = context;
             const debugMode = (0, utils._o)();
             core_.logger.level = debugMode ? 'verbose' : 'error';
             const writeToDisk = dev.writeToDisk || debugMode;
             const rsbuildInstance = await (0, core_.createRsbuild)({
                 callerName: 'rstest',
                 rsbuildConfig: {
-                    tools,
-                    resolve,
-                    source,
-                    output,
                     server: {
                         printUrls: false,
                         strictPort: false,
@@ -467,9 +469,17 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         hmr: false,
                         writeToDisk
                     },
-                    performance,
+                    environments: Object.fromEntries(context.projects.map((project)=>[
+                            project.environmentName,
+                            {
+                                plugins: project.normalizedConfig.plugins,
+                                root: project.rootPath,
+                                output: {
+                                    target: 'node'
+                                }
+                            }
+                        ])),
                     plugins: [
-                        ...plugins || [],
                         pluginBasic(context),
                         pluginIgnoreResolveError,
                         pluginMockRuntime,
@@ -477,18 +487,64 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         pluginEntryWatch({
                             globTestSourceEntries,
                             setupFiles,
-                            configFilePath: context.configFilePath,
+                            context,
                             isWatch: 'watch' === command
                         }),
-                        pluginExternal(testEnvironment),
-                        !isolate ? pluginCacheControl(Object.values(setupFiles)) : null,
+                        pluginExternal(context),
+                        !isolate ? pluginCacheControl(Object.values(setupFiles).flatMap((files)=>Object.values(files))) : null,
                         pluginInspect()
                     ].filter(Boolean)
                 }
             });
             return rsbuildInstance;
         };
-        const createRsbuildServer = async ({ name, globTestSourceEntries, setupFiles, rsbuildInstance, normalizedConfig })=>{
+        const calcEntriesToRerun = (entries, chunks, buildData, runtimeChunkName)=>{
+            const entryToChunkHashesMap = new Map();
+            const buildChunkHashes = (entry)=>{
+                const validChunks = (entry.chunks || []).filter((chunk)=>chunk !== runtimeChunkName);
+                validChunks.forEach((chunkName)=>{
+                    const chunkInfo = chunks?.find((c)=>c.names?.includes(chunkName));
+                    if (chunkInfo) {
+                        const existing = entryToChunkHashesMap.get(entry.testPath) || {};
+                        existing[chunkName] = chunkInfo.hash ?? '';
+                        entryToChunkHashesMap.set(entry.testPath, existing);
+                    }
+                });
+            };
+            (entries || []).forEach(buildChunkHashes);
+            const entryToChunkHashes = Array.from(entryToChunkHashesMap.entries()).map(([name, chunks])=>({
+                    name,
+                    chunks
+                }));
+            const affectedTestPaths = new Set();
+            const deletedEntries = [];
+            if (buildData.entryToChunkHashes) {
+                const prevMap = new Map(buildData.entryToChunkHashes.map((e)=>[
+                        e.name,
+                        e.chunks
+                    ]));
+                const currentNames = new Set(entryToChunkHashesMap.keys());
+                deletedEntries.push(...Array.from(prevMap.keys()).filter((name)=>!currentNames.has(name)));
+                const findAffectedEntry = (testPath)=>{
+                    const currentChunks = entryToChunkHashesMap.get(testPath);
+                    const prevChunks = prevMap.get(testPath);
+                    if (!currentChunks) return;
+                    if (!prevChunks) return void affectedTestPaths.add(testPath);
+                    const hasChanges = Object.entries(currentChunks).some(([chunkName, hash])=>prevChunks[chunkName] !== hash);
+                    if (hasChanges) affectedTestPaths.add(testPath);
+                };
+                entryToChunkHashesMap.forEach((_, testPath)=>{
+                    findAffectedEntry(testPath);
+                });
+            }
+            buildData.entryToChunkHashes = entryToChunkHashes;
+            const affectedEntries = Array.from(affectedTestPaths).map((testPath)=>entries.find((e)=>e.testPath === testPath)).filter((entry)=>void 0 !== entry);
+            return {
+                affectedEntries,
+                deletedEntries
+            };
+        };
+        const createRsbuildServer = async ({ globTestSourceEntries, setupFiles, rsbuildInstance, normalizedConfig })=>{
             let rspackCompiler;
             const rstestCompilerPlugin = {
                 name: 'rstest:compiler',
@@ -513,10 +569,26 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
             if (!rspackCompiler) throw new Error('rspackCompiler was not initialized');
             const outputFileSystem = isMultiCompiler(rspackCompiler) ? rspackCompiler.compilers[0].outputFileSystem : rspackCompiler.outputFileSystem;
             if (!outputFileSystem) throw new Error(`Expect outputFileSystem to be defined, but got ${outputFileSystem}`);
-            const getRsbuildStats = async ({ fileFilters } = {})=>{
-                const stats = await devServer.environments[name].getStats();
-                const manifest = devServer.environments[name].context.manifest;
-                const { entrypoints, outputPath, assets, hash, time: buildTime } = stats.toJson({
+            const readFile = async (fileName)=>new Promise((resolve, reject)=>{
+                    outputFileSystem.readFile(fileName, (err, data)=>{
+                        if (err) reject(err);
+                        resolve('string' == typeof data ? data : data.toString());
+                    });
+                });
+            const buildData = {};
+            const getEntryFiles = async (manifest, outputPath)=>{
+                const entryFiles = {};
+                const entries = Object.keys(manifest.entries);
+                for (const entry of entries){
+                    const data = manifest.entries[entry];
+                    entryFiles[entry] = ((data?.initial?.js || []).concat(data?.async?.js || []) || []).map((file)=>external_pathe_["default"].join(outputPath, file));
+                }
+                return entryFiles;
+            };
+            const getRsbuildStats = async ({ environmentName, fileFilters })=>{
+                const stats = await devServer.environments[environmentName].getStats();
+                const manifest = devServer.environments[environmentName].context.manifest;
+                const { entrypoints, outputPath, assets, hash, time: buildTime, chunks } = stats.toJson({
                     all: false,
                     hash: true,
                     entrypoints: true,
@@ -524,41 +596,29 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     assets: true,
                     relatedAssets: true,
                     cachedAssets: true,
+                    chunks: true,
                     timings: true
                 });
-                const readFile = async (fileName)=>new Promise((resolve, reject)=>{
-                        outputFileSystem.readFile(fileName, (err, data)=>{
-                            if (err) reject(err);
-                            resolve('string' == typeof data ? data : data.toString());
-                        });
-                    });
-                const getEntryFiles = async ()=>{
-                    const entryFiles = {};
-                    const entries = Object.keys(manifest.entries);
-                    for (const entry of entries){
-                        const data = manifest.entries[entry];
-                        entryFiles[entry] = ((data?.initial?.js || []).concat(data?.async?.js || []) || []).map((file)=>external_pathe_["default"].join(outputPath, file));
-                    }
-                    return entryFiles;
-                };
-                const entryFiles = await getEntryFiles();
+                const entryFiles = await getEntryFiles(manifest, outputPath);
                 const entries = [];
                 const setupEntries = [];
-                const sourceEntries = await globTestSourceEntries();
+                const sourceEntries = await globTestSourceEntries(environmentName);
                 for (const entry of Object.keys(entrypoints)){
                     const e = entrypoints[entry];
                     const distPath = external_pathe_["default"].join(outputPath, e.assets[e.assets.length - 1].name);
-                    if (setupFiles[entry]) setupEntries.push({
+                    if (setupFiles[environmentName][entry]) setupEntries.push({
                         distPath,
-                        testPath: setupFiles[entry],
-                        files: entryFiles[entry]
+                        testPath: setupFiles[environmentName][entry],
+                        files: entryFiles[entry],
+                        chunks: e.chunks || []
                     });
                     else if (sourceEntries[entry]) {
                         if (fileFilters?.length && !fileFilters.includes(sourceEntries[entry])) continue;
                         entries.push({
                             distPath,
                             testPath: sourceEntries[entry],
-                            files: entryFiles[entry]
+                            files: entryFiles[entry],
+                            chunks: e.chunks || []
                         });
                     }
                 }
@@ -586,7 +646,11 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         null
                     ];
                 }))).filter((asset)=>null !== asset[1]));
+                buildData[environmentName] ??= {};
+                const { affectedEntries, deletedEntries } = calcEntriesToRerun(entries, chunks, buildData[environmentName], `${environmentName}-${RUNTIME_CHUNK_NAME}`);
                 return {
+                    affectedEntries,
+                    deletedEntries,
                     hash,
                     entries,
                     setupEntries,
@@ -753,7 +817,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                 ].filter(Boolean),
                 env: {
                     NODE_ENV: 'test',
-                    FORCE_COLOR: '1',
+                    FORCE_COLOR: '1' === process.env.NO_COLOR ? '0' : '1',
                     ...process.env
                 }
             });
@@ -772,10 +836,11 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                 }
             };
             return {
-                runTests: async ({ entries, assetFiles, setupEntries, sourceMaps, updateSnapshot })=>{
+                runTests: async ({ entries, assetFiles, setupEntries, sourceMaps, project, updateSnapshot })=>{
+                    const projectName = context.normalizedConfig.name;
+                    const runtimeConfig = getRuntimeConfig(project);
                     const setupAssets = setupEntries.flatMap((entry)=>entry.files || []);
                     const entryLength = Object.keys(entries).length;
-                    const runtimeConfig = getRuntimeConfig(context);
                     const results = await Promise.all(entries.map((entryInfo)=>{
                         const { assetFiles: neededFiles, sourceMaps: neededSourceMaps } = filterAssetsByEntry(entryInfo, assetFiles, setupAssets, sourceMaps, entryLength);
                         return pool.runTest({
@@ -783,6 +848,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                                 entryInfo,
                                 assetFiles: neededFiles,
                                 context: {
+                                    project: projectName,
                                     rootPath: context.rootPath,
                                     runtimeConfig: (0, utils.Ok)(runtimeConfig)
                                 },
@@ -795,6 +861,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         }).catch((err)=>{
                             err.fullStack = true;
                             return {
+                                project: projectName,
                                 testPath: entryInfo.testPath,
                                 status: 'fail',
                                 name: '',
@@ -809,13 +876,15 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     const testResults = results.flatMap((r)=>r.results);
                     return {
                         results,
-                        testResults
+                        testResults,
+                        project
                     };
                 },
-                collectTests: async ({ entries, assetFiles, setupEntries, sourceMaps, updateSnapshot })=>{
+                collectTests: async ({ entries, assetFiles, setupEntries, sourceMaps, project, updateSnapshot })=>{
+                    const runtimeConfig = getRuntimeConfig(project);
+                    const projectName = project.normalizedConfig.name;
                     const setupAssets = setupEntries.flatMap((entry)=>entry.files || []);
                     const entryLength = Object.keys(entries).length;
-                    const runtimeConfig = getRuntimeConfig(context);
                     return Promise.all(entries.map((entryInfo)=>{
                         const { assetFiles: neededFiles, sourceMaps: neededSourceMaps } = filterAssetsByEntry(entryInfo, assetFiles, setupAssets, sourceMaps, entryLength);
                         return pool.collectTests({
@@ -823,6 +892,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                                 entryInfo,
                                 assetFiles: neededFiles,
                                 context: {
+                                    project: projectName,
                                     rootPath: context.rootPath,
                                     runtimeConfig: (0, utils.Ok)(runtimeConfig)
                                 },
@@ -835,6 +905,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                         }).catch((err)=>{
                             err.fullStack = true;
                             return {
+                                project: projectName,
                                 testPath: entryInfo.testPath,
                                 tests: [],
                                 errors: [

package/dist/index.js

@@ -2181,8 +2181,8 @@ var __webpack_modules__ = {
     },
     "./src/cli/commands.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            a8: ()=>runRest,
-            QF: ()=>setupCommands
+            a: ()=>runRest,
+            Q: ()=>setupCommands
         });
         var external_events_ = __webpack_require__("events");
         function toArr(any) {
@@ -2671,7 +2671,6 @@ ${section.body}` : section.body).join("\n\n"));
         const cac = (name = "")=>new CAC(name);
         const dist = cac;
         var external_pathe_ = __webpack_require__("pathe");
-        var src_config = __webpack_require__("./src/config.ts");
         var helper = __webpack_require__("./src/utils/helper.ts");
         var logger = __webpack_require__("./src/utils/logger.ts");
         var prepare = __webpack_require__("./src/cli/prepare.ts");
@@ -2680,52 +2679,16 @@ ${section.body}` : section.body).join("\n\n"));
                 default: 'jiti'
             }).option('-r, --root <root>', 'Specify the project root directory, can be an absolute path or a path relative to cwd').option('--globals', 'Provide global APIs').option('--isolate', 'Run tests in an isolated environment').option('--include <include>', 'Match test files').option('--exclude <exclude>', 'Exclude files from test').option('-u, --update', 'Update snapshot files').option('--passWithNoTests', 'Allows the test suite to pass when no files are found').option('--printConsoleTrace', 'Print console traces when calling any console method').option('--disableConsoleIntercept', 'Disable console intercept').option('--slowTestThreshold <value>', 'The number of milliseconds after which a test or suite is considered slow').option('--reporter <reporter>', 'Specify the reporter to use').option('-t, --testNamePattern <value>', 'Run only tests with a name that matches the regex').option('--testEnvironment <name>', 'The environment that will be used for testing').option('--testTimeout <value>', 'Timeout of a test in milliseconds').option('--hookTimeout <value>', 'Timeout of hook in milliseconds').option('--retry <retry>', 'Number of times to retry a test if it fails').option('--maxConcurrency <value>', 'Maximum number of concurrent tests').option('--clearMocks', 'Automatically clear mock calls, instances, contexts and results before every test').option('--resetMocks', 'Automatically reset mock state before every test').option('--restoreMocks', 'Automatically restore mock state and implementation before every test').option('--unstubGlobals', 'Restores all global variables that were changed with `rstest.stubGlobal` before every test').option('--unstubEnvs', 'Restores all `process.env` values that were changed with `rstest.stubEnv` before every test');
         };
-        async function initCli(options) {
-            const cwd = process.cwd();
-            const root = options.root ? (0, helper.FI)(cwd, options.root) : cwd;
-            const { content: config, filePath: configFilePath } = await (0, src_config.Z9)({
-                cwd: root,
-                path: options.config,
-                configLoader: options.configLoader
-            });
-            const keys = [
-                'root',
-                'globals',
-                'isolate',
-                'passWithNoTests',
-                'update',
-                'testNamePattern',
-                'testTimeout',
-                'hookTimeout',
-                'clearMocks',
-                'resetMocks',
-                'restoreMocks',
-                'unstubEnvs',
-                'unstubGlobals',
-                'retry',
-                'slowTestThreshold',
-                'maxConcurrency',
-                'printConsoleTrace',
-                'disableConsoleIntercept',
-                'testEnvironment'
-            ];
-            for (const key of keys)if (void 0 !== options[key]) config[key] = options[key];
-            if (options.exclude) config.exclude = (0, helper.bg)(options.exclude);
-            if (options.reporter) config.reporters = (0, helper.bg)(options.reporter);
-            if (options.include) config.include = (0, helper.bg)(options.include);
-            return {
-                config,
-                configFilePath: configFilePath ?? void 0
-            };
-        }
         const runRest = async ({ options, filters, command })=>{
             let rstest;
             try {
-                const { config, configFilePath } = await initCli(options);
-                const { createRstest } = await __webpack_require__.e("698").then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
+                const { initCli } = await __webpack_require__.e("223").then(__webpack_require__.bind(__webpack_require__, "./src/cli/init.ts"));
+                const { config, configFilePath, projects } = await initCli(options);
+                const { createRstest } = await __webpack_require__.e("12").then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
                 rstest = createRstest({
                     config,
-                    configFilePath
+                    configFilePath,
+                    projects
                 }, command, filters.map(external_pathe_.normalize));
                 if ('watch' === command && configFilePath) {
                     const { watchFilesForRestart } = await __webpack_require__.e("967").then(__webpack_require__.bind(__webpack_require__, "./src/core/restart.ts"));
@@ -2738,15 +2701,15 @@ ${section.body}` : section.body).join("\n\n"));
                 await rstest.runTests();
             } catch (err) {
                 for (const reporter of rstest?.context.reporters || [])reporter.onExit?.();
-                logger.v.error('Failed to run Rstest.');
-                logger.v.error((0, helper.Wk)(err));
+                logger.vF.error('Failed to run Rstest.');
+                logger.vF.error((0, helper.Wk)(err));
                 process.exit(1);
             }
         };
         function setupCommands() {
             const cli = dist('rstest');
             cli.help();
-            cli.version("0.2.2");
+            cli.version("0.3.0");
             applyCommonOptions(cli);
             cli.command('[...filters]', 'run tests').option('-w, --watch', 'Run tests in watch mode').action(async (filters, options)=>{
                 (0, prepare.N)();
@@ -2779,19 +2742,21 @@ ${section.body}` : section.body).join("\n\n"));
             });
             cli.command('list [...filters]', 'lists all test files that Rstest will run').option('--filesOnly', 'only list the test files').option('--json [boolean/path]', 'print tests as JSON or write to a file').action(async (filters, options)=>{
                 try {
-                    const { config, configFilePath } = await initCli(options);
-                    const { createRstest } = await __webpack_require__.e("698").then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
+                    const { initCli } = await __webpack_require__.e("223").then(__webpack_require__.bind(__webpack_require__, "./src/cli/init.ts"));
+                    const { config, configFilePath, projects } = await initCli(options);
+                    const { createRstest } = await __webpack_require__.e("12").then(__webpack_require__.bind(__webpack_require__, "./src/core/index.ts"));
                     const rstest = createRstest({
                         config,
-                        configFilePath
+                        configFilePath,
+                        projects
                     }, 'list', filters.map(external_pathe_.normalize));
                     await rstest.listTests({
                         filesOnly: options.filesOnly,
                         json: options.json
                     });
                 } catch (err) {
-                    logger.v.error('Failed to run Rstest list.');
-                    logger.v.error((0, helper.Wk)(err));
+                    logger.vF.error('Failed to run Rstest list.');
+                    logger.vF.error((0, helper.Wk)(err));
                     process.exit(1);
                 }
             });
@@ -2814,8 +2779,8 @@ ${section.body}` : section.body).join("\n\n"));
             if (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) console.log();
         }
         function showRstest() {
-            _utils_logger__WEBPACK_IMPORTED_MODULE_0__.v.greet("  Rstest v0.2.2");
-            _utils_logger__WEBPACK_IMPORTED_MODULE_0__.v.log('');
+            _utils_logger__WEBPACK_IMPORTED_MODULE_0__.vF.greet("  Rstest v0.3.0");
+            _utils_logger__WEBPACK_IMPORTED_MODULE_0__.vF.log('');
         }
     },
     "./src/config.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -3095,15 +3060,17 @@ ${section.body}` : section.body).join("\n\n"));
             XJ: ()=>formatTestPath,
             zZ: ()=>constants.zZ,
             fN: ()=>helper.fN,
-            vF: ()=>logger.v,
+            vF: ()=>logger.vF,
             vO: ()=>constants.vO,
             tG: ()=>getTestEntries,
+            FI: ()=>helper.FI,
             kv: ()=>constants.kv,
             yW: ()=>helper.yW,
             EQ: ()=>prettyTestPath,
-            _o: ()=>logger._,
+            _o: ()=>logger._o,
             pr: ()=>getSetupFiles,
             Kv: ()=>helper.Kv,
+            mT: ()=>logger.mT,
             t: ()=>constants.t,
             kV: ()=>helper.kV,
             EJ: ()=>constants.EJ,
@@ -3210,8 +3177,9 @@ ${section.body}` : section.body).join("\n\n"));
     },
     "./src/utils/logger.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            v: ()=>src_logger,
-            _: ()=>isDebug
+            _o: ()=>isDebug,
+            mT: ()=>clearScreen,
+            vF: ()=>src_logger
         });
         var external_node_os_ = __webpack_require__("node:os");
         var external_node_tty_ = __webpack_require__("node:tty");
@@ -3486,6 +3454,9 @@ ${section.body}` : section.body).join("\n\n"));
                 console.log(`  ${helper.yW.magenta('rstest')} ${time} ${message}`, ...args);
             }
         });
+        const clearScreen = (force = false)=>{
+            if (!isDebug() || force) console.log('\x1Bc');
+        };
     },
     "@rsbuild/core": function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE__rsbuild_core_1b356efc__;
@@ -3546,6 +3517,7 @@ ${section.body}` : section.body).join("\n\n"));
     },
     "../../node_modules/.pnpm/tinyglobby@0.2.14/node_modules/tinyglobby/dist/index.mjs": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
+            ey: ()=>isDynamicPattern,
             glob: ()=>glob
         });
         var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("node:path");
@@ -3866,10 +3838,10 @@ var prepare = __webpack_require__("./src/cli/prepare.ts");
 async function runCLI() {
     (0, prepare.k)();
     try {
-        (0, commands.QF)();
+        (0, commands.Q)();
     } catch (err) {
-        logger.v.error('Failed to start Rstest CLI.');
-        logger.v.error(err);
+        logger.vF.error('Failed to start Rstest CLI.');
+        logger.vF.error(err);
     }
 }
 var src_config = __webpack_require__("./src/config.ts");