@rstest/core 0.2.1 → 0.3.0

package/dist/{285.js → 971.js}

@@ -1,7 +1,8 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
+export const __webpack_id__ = "971";
 export const __webpack_ids__ = [
-    "285"
+    "971"
 ];
 export const __webpack_modules__ = {
     "./src/core/listTests.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -14,61 +15,89 @@ export const __webpack_modules__ = {
         var _utils__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./src/utils/index.ts");
         var _rsbuild__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./src/core/rsbuild.ts");
         async function listTests(context, { filesOnly, json }) {
-            const { normalizedConfig: { include, exclude, root, name, setupFiles: setups, includeSource }, rootPath } = context;
-            const testEntries = await (0, _utils__WEBPACK_IMPORTED_MODULE_3__.GL)({
-                include,
-                exclude,
-                root,
-                fileFilters: context.fileFilters || [],
-                includeSource
-            });
-            const globTestSourceEntries = async ()=>testEntries;
-            const setupFiles = (0, _utils__WEBPACK_IMPORTED_MODULE_3__.aA)(setups, rootPath);
-            const rsbuildInstance = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.z)(context, globTestSourceEntries, setupFiles);
-            const { getRsbuildStats, closeServer } = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.r)({
-                name,
+            const { rootPath } = context;
+            const testEntries = {};
+            const globTestSourceEntries = async (name)=>{
+                if (testEntries[name]) return testEntries[name];
+                const { include, exclude, includeSource, root } = context.projects.find((p)=>p.environmentName === name).normalizedConfig;
+                const entries = await (0, _utils__WEBPACK_IMPORTED_MODULE_3__.tG)({
+                    include,
+                    exclude,
+                    root,
+                    fileFilters: context.fileFilters || [],
+                    includeSource
+                });
+                testEntries[name] = entries;
+                return entries;
+            };
+            const setupFiles = Object.fromEntries(context.projects.map((project)=>{
+                const { environmentName, rootPath, normalizedConfig: { setupFiles } } = project;
+                return [
+                    environmentName,
+                    (0, _utils__WEBPACK_IMPORTED_MODULE_3__.pr)(setupFiles, rootPath)
+                ];
+            }));
+            const rsbuildInstance = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.zh)(context, globTestSourceEntries, setupFiles);
+            const { getRsbuildStats, closeServer } = await (0, _rsbuild__WEBPACK_IMPORTED_MODULE_4__.XD)({
                 globTestSourceEntries,
                 normalizedConfig: context.normalizedConfig,
                 setupFiles,
                 rsbuildInstance,
                 rootPath
             });
-            const { entries, setupEntries, assetFiles, sourceMaps, getSourcemap } = await getRsbuildStats();
-            const pool = await (0, _pool__WEBPACK_IMPORTED_MODULE_2__.K)({
+            const pool = await (0, _pool__WEBPACK_IMPORTED_MODULE_2__.b)({
                 context
             });
-            const list = await pool.collectTests({
-                context,
-                entries,
-                sourceMaps,
-                setupEntries,
-                assetFiles,
-                updateSnapshot: context.snapshotManager.options.updateSnapshot
-            });
+            const updateSnapshot = context.snapshotManager.options.updateSnapshot;
+            const returns = await Promise.all(context.projects.map(async (project)=>{
+                const { entries, setupEntries, assetFiles, sourceMaps } = await getRsbuildStats({
+                    environmentName: project.environmentName
+                });
+                const list = await pool.collectTests({
+                    entries,
+                    sourceMaps,
+                    setupEntries,
+                    assetFiles,
+                    project,
+                    updateSnapshot
+                });
+                return {
+                    list,
+                    sourceMaps
+                };
+            }));
+            const list = returns.flatMap((r)=>r.list);
+            const sourceMaps = Object.assign({}, ...returns.map((r)=>r.sourceMaps));
             const tests = [];
             const traverseTests = (test)=>{
                 if ([
                     'skip',
                     'todo'
                 ].includes(test.runMode)) return;
-                if ('case' === test.type) tests.push({
+                if ('case' === test.type) if (showProject) tests.push({
+                    file: test.testPath,
+                    name: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.fN)(test),
+                    project: test.project
+                });
+                else tests.push({
                     file: test.testPath,
-                    name: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.Yz)(test)
+                    name: (0, _utils__WEBPACK_IMPORTED_MODULE_3__.fN)(test)
                 });
                 else for (const child of test.tests)traverseTests(child);
             };
             const hasError = list.some((file)=>file.errors?.length);
+            const showProject = context.projects.length > 1;
             if (hasError) {
                 const { printError } = await Promise.all([
-                    __webpack_require__.e("723"),
-                    __webpack_require__.e("355")
+                    __webpack_require__.e("829"),
+                    __webpack_require__.e("704")
                 ]).then(__webpack_require__.bind(__webpack_require__, "./src/utils/error.ts"));
                 process.exitCode = 1;
                 for (const file of list){
                     const relativePath = (0, node_path__WEBPACK_IMPORTED_MODULE_1__.relative)(rootPath, file.testPath);
                     if (file.errors?.length) {
-                        _utils__WEBPACK_IMPORTED_MODULE_3__.kg.log(`${_utils__WEBPACK_IMPORTED_MODULE_3__.$_.bgRed(' FAIL ')} ${relativePath}`);
-                        for (const error of file.errors)await printError(error, getSourcemap, rootPath);
+                        _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(`${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.bgRed(' FAIL ')} ${relativePath}`);
+                        for (const error of file.errors)await printError(error, (name)=>sourceMaps[name] || null, rootPath);
                     }
                 }
                 await closeServer();
@@ -77,7 +106,11 @@ export const __webpack_modules__ = {
             }
             for (const file of list){
                 if (filesOnly) {
-                    tests.push({
+                    if (showProject) tests.push({
+                        file: file.testPath,
+                        project: file.project
+                    });
+                    else tests.push({
                         file: file.testPath
                     });
                     continue;
@@ -92,10 +125,10 @@ export const __webpack_modules__ = {
                         recursive: true
                     });
                     (0, node_fs__WEBPACK_IMPORTED_MODULE_0__.writeFileSync)(jsonPath, content);
-                } else _utils__WEBPACK_IMPORTED_MODULE_3__.kg.log(content);
+                } else _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(content);
             } else for (const test of tests){
                 const shortPath = (0, node_path__WEBPACK_IMPORTED_MODULE_1__.relative)(rootPath, test.file);
-                _utils__WEBPACK_IMPORTED_MODULE_3__.kg.log(test.name ? `${_utils__WEBPACK_IMPORTED_MODULE_3__.$_.dim(`${shortPath} > `)}${test.name}` : (0, _utils__WEBPACK_IMPORTED_MODULE_3__.aj)(shortPath));
+                _utils__WEBPACK_IMPORTED_MODULE_3__.vF.log(test.name ? `${_utils__WEBPACK_IMPORTED_MODULE_3__.yW.dim(`${shortPath} > `)}${test.name}` : (0, _utils__WEBPACK_IMPORTED_MODULE_3__.EQ)(shortPath));
             }
             await closeServer();
             await pool.close();

package/dist/{854.js → 985.js}

@@ -1,42 +1,44 @@
 import 'module';
 /*#__PURE__*/ import.meta.url;
+export const __webpack_id__ = "985";
 export const __webpack_ids__ = [
-    "854"
+    "985"
 ];
 export const __webpack_modules__ = {
     "./src/core/rsbuild.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            r: ()=>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.Nk
+                                    root: context.projects.length > 1 ? `${utils.zZ}/${name}` : utils.zZ
                                 }
                             },
                             tools: {
@@ -50,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 = {
@@ -73,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 ??= {};
@@ -88,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");
@@ -141,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.XQ)(config.watchOptions.ignored || []);
+                            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.f1, '**/*.snap');
+                            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
                             };
                         }
@@ -188,17 +192,19 @@ export const __webpack_modules__ = {
         };
         function autoExternalNodeBuiltin({ request, dependencyType }, callback) {
             if (!request) return void callback();
-            const isNodeBuiltin = utils.Tn.some((builtin)=>{
+            const isNodeBuiltin = utils.Kv.some((builtin)=>{
                 if ('string' == typeof builtin) return builtin === request;
                 return builtin.test(request);
             });
             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
@@ -206,7 +212,7 @@ export const __webpack_modules__ = {
                             },
                             tools: {
                                 rspack: (config)=>{
-                                    config.externals = (0, utils.XQ)(config.externals) || [];
+                                    config.externals = (0, utils.bg)(config.externals) || [];
                                     config.externals.unshift({
                                         '@rstest/core': 'global @rstest/core'
                                     });
@@ -215,7 +221,8 @@ export const __webpack_modules__ = {
                                     config.externals.push(autoExternalNodeBuiltin);
                                 }
                             }
-                        }));
+                        });
+                    });
                 }
             });
         class IgnoreModuleNotFoundErrorPlugin {
@@ -443,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 debugMode = (0, utils.L1)();
+            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,
@@ -466,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,
@@ -476,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',
@@ -503,7 +560,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
             const devServer = await rsbuildInstance.createDevServer({
                 getPortSilently: true
             });
-            if ((0, utils.L1)()) await rsbuildInstance.inspectConfig({
+            if ((0, utils._o)()) await rsbuildInstance.inspectConfig({
                 writeToDisk: true,
                 extraConfigs: {
                     rstest: normalizedConfig
@@ -512,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,
@@ -523,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 || []
                         });
                     }
                 }
@@ -585,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,
@@ -609,7 +674,7 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
     },
     "./src/pool/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.d(__webpack_exports__, {
-            K: ()=>createPool
+            b: ()=>createPool
         });
         var external_node_os_ = __webpack_require__("node:os");
         var utils = __webpack_require__("./src/utils/index.ts");
@@ -748,11 +813,11 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                     '--experimental-vm-modules',
                     '--experimental-import-meta-resolve',
                     '--no-warnings',
-                    (0, utils.PA)() ? '--experimental-detect-module' : void 0
+                    (0, utils.C3)() ? '--experimental-detect-module' : void 0
                 ].filter(Boolean),
                 env: {
                     NODE_ENV: 'test',
-                    FORCE_COLOR: '1',
+                    FORCE_COLOR: '1' === process.env.NO_COLOR ? '0' : '1',
                     ...process.env
                 }
             });
@@ -771,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({
@@ -782,8 +848,9 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                                 entryInfo,
                                 assetFiles: neededFiles,
                                 context: {
+                                    project: projectName,
                                     rootPath: context.rootPath,
-                                    runtimeConfig: (0, utils.v8)(runtimeConfig)
+                                    runtimeConfig: (0, utils.Ok)(runtimeConfig)
                                 },
                                 type: 'run',
                                 sourceMaps: neededSourceMaps,
@@ -794,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: '',
@@ -808,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({
@@ -822,8 +892,9 @@ global.__rstest_clean_core_cache__ = __rstest_clean_core_cache__;
                                 entryInfo,
                                 assetFiles: neededFiles,
                                 context: {
+                                    project: projectName,
                                     rootPath: context.rootPath,
-                                    runtimeConfig: (0, utils.v8)(runtimeConfig)
+                                    runtimeConfig: (0, utils.Ok)(runtimeConfig)
                                 },
                                 type: 'collect',
                                 sourceMaps: neededSourceMaps,
@@ -834,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: [