@rstest/browser 0.11.3 → 0.11.5

package/dist/index.js

@@ -1,4 +1,4 @@
-import { DEFAULT_TEST_TIMEOUT, PhaseTracker, RSTEST_ENV_SYMBOL_KEY, applyWebMockRspackConfig, browserIgnoredRuntimeConfigKeys, buildBrowserCoverageMap, color, createCoverageProvider, createRunnerEventSink, createSilentConsoleController, getNoTestFilesMessage, getNumCpus as browser_getNumCpus, getPrettyConsoleName, getSetupFiles, getTestEntries, hasUserRstestConfigPlugins, importMetaRstestDefine, initModifyRstestConfigHooks, isDebug, isTTY, loadCoverageProvider, logger, pluginMockRuntime, prepareWatchRerunState, projectRuntimeConfig, resolveProjectBuildCache, resolveShardedEntries, resolveSnapshotPathDefault, resolveWorkerCount, rsbuild, serializableConfig } from "@rstest/core/internal/browser";
+import { DEFAULT_TEST_TIMEOUT, FATAL_SIGNALS, PhaseTracker, RSTEST_ENV_SYMBOL_KEY, applyWatchInvalidation, applyWebMockRspackConfig, browserIgnoredRuntimeConfigKeys, buildBrowserCoverageMap, color, createCoverageProvider, createRunnerEventSink, createSilentConsoleController, finalizeRunCycle, getNoTestFilesMessage, getNumCpus as browser_getNumCpus, getPrettyConsoleName, getSetupFiles, getTestEntries, hasUserRstestConfigPlugins, importMetaRstestDefine, initModifyRstestConfigHooks, isDebug, isTTY, loadCoverageProvider, logWatchReadyMessage, logger, pluginMockRuntime, prepareWatchRerunState, projectRuntimeConfig, resolveProjectBuildCache, resolveShardedEntries, resolveSnapshotPathDefault, resolveWorkerCount, rsbuild, serializableConfig } from "@rstest/core/internal/browser";
 import { existsSync } from "node:fs";
 import promises from "node:fs/promises";
 import { fileURLToPath } from "node:url";
@@ -2054,6 +2054,11 @@ const ignoredKeyWarnings = {
         message: ()=>"Ignoring isolate: false in browser mode: each test file still runs in a fresh context.",
         browserOnly: true
     },
+    federation: {
+        isNonDefault: (config)=>true === config.federation,
+        message: ()=>'Ignoring federation in browser mode: it only applies to the Node runner.',
+        browserOnly: true
+    },
     detectAsyncLeaks: {
         isNonDefault: (config)=>true === config.detectAsyncLeaks,
         message: ()=>"Ignoring detectAsyncLeaks in browser mode: it relies on node async_hooks."
@@ -2835,44 +2840,6 @@ const loadSourceMapWithCache = async ({ jsUrl, cache, force = false, origin, fet
         return null;
     }
 };
-const isBrowserWatchCliShortcutsEnabled = ()=>isTTY('stdin');
-const getBrowserWatchCliShortcutsHintMessage = ()=>`  ${color.dim('press')} ${color.bold('q')} ${color.dim('to quit')}\n`;
-const logBrowserWatchReadyMessage = (enableCliShortcuts)=>{
-    logger.log(color.green('  Waiting for file changes...'));
-    if (enableCliShortcuts) logger.log(getBrowserWatchCliShortcutsHintMessage());
-};
-async function setupBrowserWatchCliShortcuts({ close }) {
-    const { emitKeypressEvents } = await import("node:readline");
-    emitKeypressEvents(process.stdin);
-    process.stdin.setRawMode(true);
-    process.stdin.resume();
-    process.stdin.setEncoding('utf8');
-    let isClosing = false;
-    const handleKeypress = (str, key)=>{
-        if (key.ctrl && 'c' === key.name) return void process.kill(process.pid, 'SIGINT');
-        if (key.ctrl && 'z' === key.name) {
-            if ('win32' !== process.platform) process.kill(process.pid, 'SIGTSTP');
-            return;
-        }
-        if ('q' !== str || isClosing) return;
-        isClosing = true;
-        (async ()=>{
-            try {
-                await close();
-            } finally{
-                process.exit(0);
-            }
-        })();
-    };
-    process.stdin.on('keypress', handleKeypress);
-    return ()=>{
-        try {
-            process.stdin.setRawMode(false);
-            process.stdin.pause();
-        } catch  {}
-        process.stdin.off('keypress', handleKeypress);
-    };
-}
 const serializeTestFiles = (files)=>JSON.stringify(files.map((f)=>`${f.projectName}:${f.testPath}`).sort());
 const normalizeTestFiles = (files)=>files.map((file)=>({
             ...file,
@@ -3004,6 +2971,9 @@ class ContainerRpcManager {
     async notifyTestFileUpdate(files) {
         await this.rpc?.onTestFileUpdate(files);
     }
+    async updateHostConfig(config) {
+        await this.rpc?.onHostConfigUpdate(config);
+    }
     async reloadTestFile(testFile, testNamePattern) {
         logger.debug(`[Browser UI] reloadTestFile called, rpc: ${this.rpc ? 'exists' : 'null'}, ws: ${this.ws ? 'exists' : 'null'}`);
         if (!this.rpc) throw new Error('Browser UI RPC not available for reloadTestFile');
@@ -3011,15 +2981,29 @@ class ContainerRpcManager {
         return this.rpc.reloadTestFile(testFile, testNamePattern);
     }
 }
+const createBrowserWatchState = ()=>({
+        lastTestFiles: [],
+        hooksEnabled: false,
+        invalidation: new Map(),
+        pendingAffectedTestFiles: new Map(),
+        compileStartTimes: new Map(),
+        pendingBuildTimeMs: 0
+    });
+const drainPendingBuildTime = (watchState)=>{
+    const buildTime = watchState.pendingBuildTimeMs;
+    watchState.pendingBuildTimeMs = 0;
+    return buildTime;
+};
+const drainPendingAffectedTestFiles = (watchState)=>{
+    const affected = new Set();
+    for (const files of watchState.pendingAffectedTestFiles.values())for (const file of files)affected.add(file);
+    watchState.pendingAffectedTestFiles.clear();
+    return Array.from(affected);
+};
 const watchContext = {
     runtime: null,
-    lastTestFiles: [],
-    hooksEnabled: false,
     cleanupRegistered: false,
-    cleanupPromise: null,
-    closeCliShortcuts: null,
-    chunkHashes: new Map(),
-    affectedTestFiles: []
+    cleanupPromise: null
 };
 const resolveViewport = (viewport)=>{
     if (!viewport) return null;
@@ -3202,25 +3186,42 @@ const getChunkKey = (chunk)=>{
     if (chunk.files && chunk.files.length > 0) return chunk.files[0];
     return null;
 };
-const getAffectedTestFiles = (chunks, entryTestFiles)=>{
-    if (!chunks) return [];
-    const affectedFiles = new Set();
-    const currentHashes = new Map();
-    for (const chunk of chunks){
+const getAffectedTestFiles = ({ chunks, entryTestFiles, setupFiles, state })=>{
+    const entryHashes = new Map();
+    const setupHashes = new Map();
+    const recordChunk = (snapshot, entryPath, chunkKey, hash)=>{
+        const record = snapshot.get(entryPath) ?? {};
+        record[chunkKey] = hash;
+        snapshot.set(entryPath, record);
+    };
+    for (const chunk of chunks || []){
         if (!chunk.hash) continue;
-        const testFile = findTestFileInModules(chunk.modules, entryTestFiles);
-        if (!testFile) continue;
         const chunkKey = getChunkKey(chunk);
         if (!chunkKey) continue;
-        const prevHash = watchContext.chunkHashes.get(chunkKey);
-        currentHashes.set(chunkKey, chunk.hash);
-        if (void 0 !== prevHash && prevHash !== chunk.hash) {
-            affectedFiles.add(testFile);
-            logger.debug(`[Watch] Chunk hash changed for ${chunkKey}: ${prevHash} -> ${chunk.hash} (test: ${testFile})`);
+        const testFile = findTestFileInModules(chunk.modules, entryTestFiles);
+        if (testFile) {
+            recordChunk(entryHashes, testFile, chunkKey, chunk.hash);
+            continue;
         }
+        const setupFile = findTestFileInModules(chunk.modules, setupFiles);
+        if (setupFile) recordChunk(setupHashes, setupFile, chunkKey, chunk.hash);
     }
-    watchContext.chunkHashes = currentHashes;
-    return Array.from(affectedFiles);
+    const seedFirstSeen = (baseline, current)=>{
+        if (!baseline) return;
+        for (const [entryPath, record] of current)if (!baseline.has(entryPath)) baseline.set(entryPath, record);
+    };
+    seedFirstSeen(state.entryHashes, entryHashes);
+    seedFirstSeen(state.setupHashes, setupHashes);
+    const outcome = applyWatchInvalidation(state, {
+        entryHashes,
+        setupHashes
+    });
+    if (outcome.rerunAll) {
+        logger.debug('[Watch] Setup file changed, re-running all test files of the project');
+        return Array.from(entryTestFiles);
+    }
+    for (const affected of outcome.affectedPaths)logger.debug(`[Watch] Chunk hash changed for test: ${affected}`);
+    return outcome.affectedPaths;
 };
 const getBrowserProjects = (context)=>context.projects.filter((project)=>project.normalizedConfig.browser.enabled);
 const getBrowserRsbuildEnvironmentConfig = (project)=>({
@@ -3426,27 +3427,22 @@ const destroyBrowserRuntime = async (runtime)=>{
 const cleanupWatchRuntime = ()=>{
     if (watchContext.cleanupPromise) return watchContext.cleanupPromise;
     watchContext.cleanupPromise = (async ()=>{
-        watchContext.closeCliShortcuts?.();
-        watchContext.closeCliShortcuts = null;
         if (!watchContext.runtime) return;
         await destroyBrowserRuntime(watchContext.runtime);
         watchContext.runtime = null;
     })();
     return watchContext.cleanupPromise;
 };
-const registerWatchCleanup = ()=>{
+const registerWatchCleanup = (embedded)=>{
     if (watchContext.cleanupRegistered) return;
-    for (const signal of [
-        'SIGINT',
-        'SIGTERM',
-        'SIGTSTP'
-    ])process.once(signal, ()=>{
+    watchContext.cleanupRegistered = true;
+    if (embedded) return;
+    for (const signal of FATAL_SIGNALS)process.once(signal, ()=>{
         cleanupWatchRuntime();
     });
     process.once('exit', ()=>{
         cleanupWatchRuntime();
     });
-    watchContext.cleanupRegistered = true;
 };
 const createBrowserRuntime = async ({ context, projectEntries: initialProjectEntries, browserProjects, shardedEntries, freezeShardedEntries, tempDir, isWatchMode, onTriggerRerun, containerDistPath, containerDevServer, forceHeadless, skipProviderLaunch, appliedModifyRstestConfigEnvironments })=>{
     const containerHtmlTemplate = containerDistPath ? await promises.readFile(join(containerDistPath, 'index.html'), 'utf-8') : null;
@@ -3459,6 +3455,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
     };
     let browserLaunchOptions = ensureConsistentBrowserLaunchOptions(browserProjects);
     let projectEntries = initialProjectEntries;
+    const watchState = createBrowserWatchState();
     const manifestModules = [];
     const createRuntimeWithoutProvider = ()=>{
         const firstProject = browserProjects[0];
@@ -3481,7 +3478,8 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
             setContainerOptions,
             dispatchHandlers,
             wss: void 0,
-            projectEntries
+            projectEntries,
+            watchState
         };
     };
     const getProjectEntry = (project)=>projectEntries.find((item)=>item.project.environmentName === project.environmentName);
@@ -3551,6 +3549,30 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
             return false;
         }
     };
+    const serveContainerRoute = async (req, res, next)=>{
+        if (!req.url) return void next();
+        const url = new URL(req.url, 'http://localhost');
+        if ('/' === url.pathname) {
+            if (await respondWithDevServerHtml(url, res)) return;
+            const html = injectedContainerHtml || containerHtmlTemplate?.replace(OPTIONS_PLACEHOLDER, 'null');
+            if (html) {
+                res.setHeader('Content-Type', 'text/html');
+                res.end(html);
+                return;
+            }
+            res.statusCode = 502;
+            res.end('Container UI is not available.');
+            return;
+        }
+        if (url.pathname.startsWith('/container-static/')) {
+            if (await proxyDevServerAsset(req, res)) return;
+            if (serveContainer) return void serveContainer(req, res, next);
+            res.statusCode = 502;
+            res.end('Container assets are not available.');
+            return;
+        }
+        next();
+    };
     const buildProjectServer = async (project, isContainerServer)=>{
         const manifestPath = join(tempDir, toSafeVarName(project.environmentName), VIRTUAL_MANIFEST_FILENAME);
         const entry = getProjectEntry(project);
@@ -3587,7 +3609,10 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                 server: {
                     printUrls: false,
                     port: project.normalizedConfig.browser.port ?? (isContainerServer ? 4000 : 0),
-                    strictPort: project.normalizedConfig.browser.strictPort
+                    strictPort: project.normalizedConfig.browser.strictPort,
+                    setup: isContainerServer ? ({ server })=>{
+                        server.middlewares.use(serveContainerRoute);
+                    } : void 0
                 },
                 dev: createBrowserRsbuildDevConfig(enableHmr),
                 environments: {
@@ -3644,9 +3669,19 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                                     target: 'web',
                                     sourceMap: {
                                         js: 'source-map'
+                                    },
+                                    distPath: {
+                                        root: join(tempDir, 'server', toSafeVarName(project.environmentName))
                                     }
                                 },
                                 tools: {
+                                    swc: (swcConfig)=>{
+                                        swcConfig.env ??= {};
+                                        swcConfig.env.exclude = Array.from(new Set([
+                                            ...swcConfig.env.exclude ?? [],
+                                            'transform-parameters'
+                                        ]));
+                                    },
                                     rspack: (rspackConfig)=>{
                                         rspackConfig.mode = 'development';
                                         applyWebMockRspackConfig(rspackConfig, {
@@ -3685,21 +3720,46 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                 name: 'rstest:browser-watch',
                 setup (api) {
                     api.onBeforeDevCompile(()=>{
-                        if (!watchContext.hooksEnabled) return;
+                        watchState.compileStartTimes.set(project.name, Date.now());
+                        if (!watchState.hooksEnabled) return;
                         logger.log(color.cyan('\nFile changed, re-running tests...\n'));
                     });
                     api.onAfterDevCompile(async ({ stats })=>{
+                        const compileStart = watchState.compileStartTimes.get(project.name);
+                        if (void 0 !== compileStart) {
+                            watchState.compileStartTimes.delete(project.name);
+                            if (watchState.hooksEnabled) watchState.pendingBuildTimeMs = Math.max(watchState.pendingBuildTimeMs, Date.now() - compileStart);
+                        }
                         if (stats) {
-                            const allProjectEntries = await collectProjectEntries(context);
-                            const entryTestFiles = new Set(collectWatchTestFiles(allProjectEntries).map((file)=>file.testPath));
+                            const [projectEntry] = await collectProjectEntries(context, [
+                                project
+                            ]);
+                            const entryTestFiles = new Set(collectWatchTestFiles(projectEntry ? [
+                                projectEntry
+                            ] : []).map((file)=>file.testPath));
+                            const setupFiles = new Set((projectEntry?.setupFiles ?? []).map((file)=>normalize(file)));
+                            let state = watchState.invalidation.get(project.name);
+                            if (!state) {
+                                state = {};
+                                watchState.invalidation.set(project.name, state);
+                            }
                             const statsJson = stats.toJson({
                                 all: true
                             });
-                            const affected = getAffectedTestFiles(statsJson.chunks, entryTestFiles);
-                            watchContext.affectedTestFiles = affected;
-                            if (affected.length > 0) logger.debug(`[Watch] Affected test files: ${affected.join(', ')}`);
+                            const affected = getAffectedTestFiles({
+                                chunks: statsJson.chunks,
+                                entryTestFiles,
+                                setupFiles,
+                                state
+                            });
+                            if (affected.length > 0) {
+                                const pending = watchState.pendingAffectedTestFiles.get(project.name) ?? new Set();
+                                for (const file of affected)pending.add(file);
+                                watchState.pendingAffectedTestFiles.set(project.name, pending);
+                                logger.debug(`[Watch] Affected test files: ${affected.join(', ')}`);
+                            }
                         }
-                        if (!watchContext.hooksEnabled) return;
+                        if (!watchState.hooksEnabled) return;
                         await onTriggerRerun();
                     });
                 }
@@ -3732,6 +3792,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
         });
         if (isDebug()) await rsbuildInstance.inspectConfig({
             writeToDisk: true,
+            outputPath: external_pathe_resolve(context.rootPath, context.normalizedConfig.output.distPath.root, '.rsbuild'),
             extraConfigs: {
                 rstest: {
                     ...context.normalizedConfig,
@@ -3766,27 +3827,6 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                 }
                 return;
             }
-            if (isContainerServer) {
-                if ('/' === url.pathname) {
-                    if (await respondWithDevServerHtml(url, res)) return;
-                    const html = injectedContainerHtml || containerHtmlTemplate?.replace(OPTIONS_PLACEHOLDER, 'null');
-                    if (html) {
-                        res.setHeader('Content-Type', 'text/html');
-                        res.end(html);
-                        return;
-                    }
-                    res.statusCode = 502;
-                    res.end('Container UI is not available.');
-                    return;
-                }
-                if (url.pathname.startsWith('/container-static/')) {
-                    if (await proxyDevServerAsset(req, res)) return;
-                    if (serveContainer) return void serveContainer(req, res, next);
-                    res.statusCode = 502;
-                    res.end('Container assets are not available.');
-                    return;
-                }
-            }
             if ('/runner.html' === url.pathname) {
                 res.setHeader('Content-Type', 'text/html');
                 res.end(htmlTemplate);
@@ -3844,7 +3884,8 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
             setContainerOptions,
             dispatchHandlers,
             wss,
-            projectEntries
+            projectEntries,
+            watchState
         };
     } catch (error) {
         wss.close();
@@ -3871,10 +3912,11 @@ async function resolveProjectEntries(context, shardedEntries, browserProjects) {
     return collectProjectEntries(context, browserProjects);
 }
 const runBrowserController = async (context, options)=>{
-    const { allowEmptyWatchRun = false, allowEmptyRun = false, filesOnly = false, onTraceEvents, env } = options ?? {};
+    const { allowEmptyRun = false, filesOnly = false, onTraceEvents, env } = options ?? {};
     const buildStart = Date.now();
     const isWatchMode = 'watch' === context.command;
     const phaseTrackers = onTraceEvents ? new Map() : void 0;
+    const trackerKey = (project, testPath)=>`${project}\u0000${testPath}`;
     const browserProjects = options?.projects ?? getBrowserProjects(context);
     const useHeadlessDirect = browserProjects.every((project)=>project.normalizedConfig.browser.headless);
     const browserSourceMapCache = new Map();
@@ -3954,27 +3996,15 @@ const runBrowserController = async (context, options)=>{
     };
     const coverageConfig = browserProjects.find((project)=>project.normalizedConfig.coverage?.enabled)?.normalizedConfig.coverage;
     const coverageProvider = coverageConfig?.enabled ? await createCoverageProvider(coverageConfig, context.rootPath) : null;
-    const notifyTestRunEnd = async ({ duration, unhandledErrors, filterRerunTestPaths })=>{
+    const notifyTestRunEnd = async ({ duration, coverage })=>{
         if (!isWatchMode) return;
-        let mergedCoverage;
-        if (coverageProvider) {
-            const coverageMap = coverageProvider.createCoverageMap();
-            let hasCoverage = false;
-            for (const result of context.reporterResults.results)if (result.coverage) {
-                coverageMap.merge(result.coverage);
-                hasCoverage = true;
-            }
-            if (hasCoverage) mergedCoverage = coverageMap.toJSON();
-        }
         for (const reporter of context.reporters)await reporter.onTestRunEnd?.({
             results: context.reporterResults.results,
-            coverage: mergedCoverage,
+            coverage,
             testResults: context.reporterResults.testResults,
             duration,
             snapshotSummary: context.snapshotManager.summary,
-            getSourcemap: getBrowserSourcemap,
-            unhandledErrors,
-            filterRerunTestPaths
+            getSourcemap: getBrowserSourcemap
         });
     };
     const containerDevServerEnv = process.env.RSTEST_CONTAINER_DEV_SERVER;
@@ -3997,7 +4027,6 @@ const runBrowserController = async (context, options)=>{
     }
     let projectEntries = await resolveProjectEntries(context, options?.shardedEntries, browserProjects);
     let totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
-    const shouldKeepWatchingWithEmptySet = isWatchMode && allowEmptyWatchRun;
     const shouldInitializeEmptyBrowserHooks = 0 === totalTests && hasUserRstestConfigPlugins(browserProjects);
     const createEmptyRunResult = ()=>{
         const elapsed = Math.max(0, Date.now() - buildStart);
@@ -4017,7 +4046,7 @@ const runBrowserController = async (context, options)=>{
     const reportEmptyTestSet = ()=>{
         const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
         if (isWatchMode || !allowEmptyRun) {
-            const message = shouldKeepWatchingWithEmptySet ? 'No test files found.' : getNoTestFilesMessage({
+            const message = getNoTestFilesMessage({
                 context,
                 code,
                 defaultMessage: `No test files found, exiting with code ${code}.`
@@ -4027,19 +4056,19 @@ const runBrowserController = async (context, options)=>{
             if (context.relatedFilters?.length) logger.log(color.gray('related: '), context.relatedFilters.join(color.gray(', ')));
             else if (context.fileFilters?.length) logger.log(color.gray('filter: '), context.fileFilters.join(color.gray(', ')));
         }
-        if (isWatchMode && 0 !== code && !shouldKeepWatchingWithEmptySet && !allowEmptyRun) ensureProcessExitCode(code);
-        return !shouldKeepWatchingWithEmptySet;
+        if (isWatchMode && 0 !== code && !allowEmptyRun) ensureProcessExitCode(code);
     };
     if (0 === totalTests && !shouldInitializeEmptyBrowserHooks) {
-        if (reportEmptyTestSet()) return allowEmptyRun ? createEmptyRunResult() : void 0;
+        reportEmptyTestSet();
+        return allowEmptyRun ? createEmptyRunResult() : void 0;
     }
     if (!filesOnly) await notifyTestRunStart();
-    const enableCliShortcuts = isWatchMode && isBrowserWatchCliShortcutsEnabled();
+    const enableCliShortcuts = isWatchMode && isTTY('stdin');
     const browserTempOutputRoot = context.normalizedConfig.output.distPath.root;
     const tempDir = isWatchMode && watchContext.runtime ? watchContext.runtime.tempDir : isWatchMode ? join(context.rootPath, browserTempOutputRoot, 'browser', 'watch') : join(context.rootPath, browserTempOutputRoot, 'browser', Date.now().toString());
-    if (isWatchMode) watchContext.lastTestFiles = collectWatchTestFiles(projectEntries);
     let runtime = isWatchMode ? watchContext.runtime : null;
     let triggerRerun;
+    let awaitHeadlessRerunIdle;
     if (!runtime) {
         try {
             runtime = await createBrowserRuntime({
@@ -4068,12 +4097,62 @@ const runBrowserController = async (context, options)=>{
         }
         if (isWatchMode) {
             watchContext.runtime = runtime;
-            registerWatchCleanup();
-            if (enableCliShortcuts && !watchContext.closeCliShortcuts) watchContext.closeCliShortcuts = await setupBrowserWatchCliShortcuts({
-                close: cleanupWatchRuntime
-            });
+            registerWatchCleanup(context.embedded);
         }
     }
+    const watchState = runtime.watchState;
+    if (isWatchMode) watchState.lastTestFiles = collectWatchTestFiles(projectEntries);
+    const seedPendingRerun = (testPaths)=>{
+        const wanted = testPaths ? new Set(testPaths.map((testPath)=>normalize(testPath))) : null;
+        let seeded = 0;
+        for (const file of watchState.lastTestFiles){
+            if (wanted && !wanted.has(file.testPath)) continue;
+            const pending = watchState.pendingAffectedTestFiles.get(file.projectName) ?? new Set();
+            pending.add(file.testPath);
+            watchState.pendingAffectedTestFiles.set(file.projectName, pending);
+            seeded += 1;
+        }
+        return seeded;
+    };
+    const watchHandles = isWatchMode ? {
+        rerun: async (testPaths)=>{
+            const seeded = seedPendingRerun(testPaths);
+            if (testPaths && 0 === seeded) return;
+            await triggerRerun?.();
+            await awaitHeadlessRerunIdle?.();
+        },
+        close: cleanupWatchRuntime
+    } : void 0;
+    const finalizeWatchRerun = async ({ rerunTestPaths, testTime, unhandledErrors })=>{
+        const rerunPathSet = new Set(rerunTestPaths);
+        const rerunResults = context.reporterResults.results.filter((result)=>rerunPathSet.has(result.testPath));
+        let rerunCoverage;
+        const coverageMap = buildBrowserCoverageMap(rerunResults, coverageProvider);
+        if (coverageMap && coverageMap.files().length > 0) rerunCoverage = coverageMap.toJSON();
+        const outcome = {
+            results: rerunResults,
+            testResults: context.reporterResults.testResults.filter((result)=>rerunPathSet.has(result.testPath)),
+            errors: unhandledErrors ?? [],
+            testPaths: rerunTestPaths,
+            duration: {
+                buildTime: drainPendingBuildTime(watchState),
+                testTime
+            },
+            coverage: rerunCoverage ? {
+                map: rerunCoverage
+            } : void 0,
+            resolveSourcemap: resolveBrowserSourcemap
+        };
+        await finalizeRunCycle(context, {
+            outcomes: [
+                outcome
+            ],
+            mode: 'on-demand',
+            isWatchMode: true,
+            coverageProvider,
+            reportOnFailure: coverageConfig?.reportOnFailure ?? false
+        });
+    };
     projectEntries = runtime.projectEntries;
     totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
     const buildTime = Date.now() - buildStart;
@@ -4090,7 +4169,8 @@ const runBrowserController = async (context, options)=>{
         resolveSourcemap: resolveBrowserSourcemap,
         close: ()=>destroyBrowserRuntime(runtime)
     };
-    if (0 === totalTests && reportEmptyTestSet()) {
+    if (0 === totalTests) {
+        reportEmptyTestSet();
         await destroyBrowserRuntime(runtime);
         return allowEmptyRun ? createEmptyRunResult() : void 0;
     }
@@ -4120,7 +4200,7 @@ const runBrowserController = async (context, options)=>{
         rootPath: normalize(context.rootPath),
         projects: projectRuntimeConfigs,
         snapshot: {
-            updateSnapshot: context.snapshotManager.options.updateSnapshot
+            updateSnapshot: options?.updateSnapshot ?? context.snapshotManager.options.updateSnapshot
         },
         runnerUrl: `http://localhost:${runtime.containerServer.port}`,
         projectRunnerUrls,
@@ -4174,19 +4254,17 @@ const runBrowserController = async (context, options)=>{
             project.name,
             createRunnerEventSink(context, project.normalizedConfig)
         ]));
-    const firstBrowserSink = runnerSinks.get(browserProjects[0].name);
-    const projectNameByTestPath = new Map();
-    const sinkForProjectName = (projectName)=>runnerSinks.get(projectName) ?? firstBrowserSink;
-    const sinkForTestPath = (testPath)=>{
-        const projectName = projectNameByTestPath.get(testPath);
-        return projectName ? sinkForProjectName(projectName) : firstBrowserSink;
+    const sinkForProjectName = (projectName)=>{
+        const sink = runnerSinks.get(projectName);
+        if (!sink) throw new Error(`No runner event sink for project "${projectName}"`);
+        return sink;
     };
     const silentConsoleController = createSilentConsoleController({
         runtimeConfig: {
             silent: context.normalizedConfig.silent,
             disableConsoleIntercept: context.normalizedConfig.disableConsoleIntercept
         },
-        emitInterceptedLog: (log)=>sinkForTestPath(log.testPath).onConsoleLog(log),
+        emitInterceptedLog: (log)=>sinkForProjectName(log.project).onConsoleLog(log),
         writeOriginalLog: ()=>{}
     });
     const snapshotRpcMethods = {
@@ -4214,7 +4292,6 @@ const runBrowserController = async (context, options)=>{
         }
     };
     const handleTestFileStart = async (payload)=>{
-        projectNameByTestPath.set(payload.testPath, payload.projectName);
         if (phaseTrackers) {
             const tracker = new PhaseTracker({
                 trace: {
@@ -4224,25 +4301,26 @@ const runBrowserController = async (context, options)=>{
                 pid: nextBrowserFilePid++
             });
             tracker.transition('prepare');
-            phaseTrackers.set(payload.testPath, tracker);
+            phaseTrackers.set(trackerKey(payload.projectName, payload.testPath), tracker);
         }
         await sinkForProjectName(payload.projectName).onTestFileStart({
             testId: getFileTaskId(payload.testPath),
             testPath: payload.testPath,
+            project: payload.projectName,
             tests: []
         });
     };
     const handleTestFileReady = async (payload)=>{
-        phaseTrackers?.get(payload.testPath)?.transition('tests');
-        await sinkForTestPath(payload.testPath).onTestFileReady(payload);
+        phaseTrackers?.get(trackerKey(payload.project, payload.testPath))?.transition('tests');
+        await sinkForProjectName(payload.project).onTestFileReady(payload);
     };
     const handleTestSuiteStart = async (payload)=>{
-        phaseTrackers?.get(payload.testPath)?.recordSuiteStart(payload);
-        await sinkForTestPath(payload.testPath).onTestSuiteStart(payload);
+        phaseTrackers?.get(trackerKey(payload.project, payload.testPath))?.recordSuiteStart(payload);
+        await sinkForProjectName(payload.project).onTestSuiteStart(payload);
     };
     const handleTestSuiteResult = async (payload)=>{
-        phaseTrackers?.get(payload.testPath)?.recordSuiteResult(payload);
-        await sinkForTestPath(payload.testPath).onTestSuiteResult(payload);
+        phaseTrackers?.get(trackerKey(payload.project, payload.testPath))?.recordSuiteResult(payload);
+        await sinkForProjectName(payload.project).onTestSuiteResult(payload);
         if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
             taskId: payload.testId,
             status: payload.status,
@@ -4252,13 +4330,13 @@ const runBrowserController = async (context, options)=>{
         });
     };
     const handleTestCaseStart = async (payload)=>{
-        phaseTrackers?.get(payload.testPath)?.recordCaseStart(payload);
-        sinkForTestPath(payload.testPath).onTestCaseStart(payload);
+        phaseTrackers?.get(trackerKey(payload.project, payload.testPath))?.recordCaseStart(payload);
+        sinkForProjectName(payload.project).onTestCaseStart(payload);
     };
     const handleTestCaseResult = async (payload)=>{
         caseResults.push(payload);
-        phaseTrackers?.get(payload.testPath)?.recordCaseResult(payload);
-        await sinkForTestPath(payload.testPath).onTestCaseResult(payload);
+        phaseTrackers?.get(trackerKey(payload.project, payload.testPath))?.recordCaseResult(payload);
+        await sinkForProjectName(payload.project).onTestCaseResult(payload);
         if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
             taskId: payload.testId,
             status: payload.status,
@@ -4273,12 +4351,13 @@ const runBrowserController = async (context, options)=>{
             payload
         ], payload.results);
         if (phaseTrackers) {
-            const tracker = phaseTrackers.get(payload.testPath);
+            const key = trackerKey(payload.project, payload.testPath);
+            const tracker = phaseTrackers.get(key);
             if (tracker) {
                 tracker.end();
                 const events = tracker.getTraceEvents();
                 if (events) onTraceEvents?.(events);
-                phaseTrackers.delete(payload.testPath);
+                phaseTrackers.delete(key);
             }
         }
         if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
@@ -4288,7 +4367,7 @@ const runBrowserController = async (context, options)=>{
             taskType: 'file',
             testPath: payload.testPath
         });
-        await sinkForTestPath(payload.testPath).onTestFileResult(payload);
+        await sinkForProjectName(payload.project).onTestFileResult(payload);
         if (isWatchMode && 'fail' === payload.status) ensureProcessExitCode(1);
     };
     const handleLog = async (payload)=>{
@@ -4300,6 +4379,7 @@ const runBrowserController = async (context, options)=>{
             taskParentNames: payload.taskParentNames,
             taskType: payload.taskType,
             testPath: payload.testPath,
+            project: payload.projectName,
             type: payload.type,
             trace: payload.trace
         };
@@ -4461,6 +4541,9 @@ const runBrowserController = async (context, options)=>{
                 });
                 const inlineOptions = {
                     ...hostOptions,
+                    snapshot: {
+                        updateSnapshot: context.snapshotManager.options.updateSnapshot
+                    },
                     testFile: file.testPath,
                     runId: `${run.token}:${session.id}`
                 };
@@ -4573,20 +4656,16 @@ const runBrowserController = async (context, options)=>{
                 } finally{
                     const testTime = Math.max(0, Date.now() - rerunStartTime);
                     const rerunFatalError = fatalError && fatalError !== fatalErrorBeforeRun ? fatalError : void 0;
-                    await notifyTestRunEnd({
-                        duration: {
-                            totalTime: testTime,
-                            buildTime: 0,
-                            testTime
-                        },
-                        filterRerunTestPaths: files.map((file)=>file.testPath),
+                    await finalizeWatchRerun({
+                        rerunTestPaths: files.map((file)=>file.testPath),
+                        testTime,
                         unhandledErrors: rerunError ? [
                             rerunError
                         ] : rerunFatalError ? [
                             rerunFatalError
                         ] : void 0
                     });
-                    logBrowserWatchReadyMessage(enableCliShortcuts);
+                    logWatchReadyMessage(context, enableCliShortcuts);
                 }
             },
             onError: async (error)=>{
@@ -4600,54 +4679,7 @@ const runBrowserController = async (context, options)=>{
                 logger.debug(`[Headless] Interrupting active run token ${run.token} before scheduling latest rerun`);
             }
         });
-        if (0 === allTestFiles.length) {
-            const duration = {
-                totalTime: buildTime,
-                buildTime,
-                testTime: 0
-            };
-            const result = {
-                results: reporterResults,
-                testResults: caseResults,
-                duration,
-                hasFailure: false,
-                getSourcemap: getBrowserSourcemap,
-                resolveSourcemap: resolveBrowserSourcemap,
-                close: isWatchMode ? void 0 : async ()=>{
-                    sessionRegistry.clear();
-                    await destroyBrowserRuntime(runtime);
-                }
-            };
-            if (isWatchMode) await notifyTestRunEnd({
-                duration
-            });
-            if (isWatchMode) {
-                triggerRerun = async ()=>{
-                    const newProjectEntries = await collectProjectEntries(context);
-                    const rerunPlan = planWatchRerun({
-                        projectEntries: newProjectEntries,
-                        previousTestFiles: watchContext.lastTestFiles,
-                        affectedTestFiles: watchContext.affectedTestFiles
-                    });
-                    watchContext.affectedTestFiles = [];
-                    if (rerunPlan.filesChanged) {
-                        watchContext.lastTestFiles = rerunPlan.currentTestFiles;
-                        if (0 === rerunPlan.currentTestFiles.length) {
-                            logger.log(color.cyan('No browser test files remain after update.\n'));
-                            logBrowserWatchReadyMessage(enableCliShortcuts);
-                            return;
-                        }
-                        logger.log(color.cyan(`Test file set changed, re-running ${rerunPlan.currentTestFiles.length} file(s)...\n`));
-                        latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
-                        return;
-                    }
-                    logBrowserWatchReadyMessage(enableCliShortcuts);
-                };
-                watchContext.hooksEnabled = true;
-                logBrowserWatchReadyMessage(enableCliShortcuts);
-            }
-            return result;
-        }
+        awaitHeadlessRerunIdle = ()=>latestRerunScheduler.whenIdle();
         const testStart = Date.now();
         await runFilesWithPool(allTestFiles);
         const testTime = Date.now() - testStart;
@@ -4655,31 +4687,30 @@ const runBrowserController = async (context, options)=>{
             const newProjectEntries = await collectProjectEntries(context);
             const rerunPlan = planWatchRerun({
                 projectEntries: newProjectEntries,
-                previousTestFiles: watchContext.lastTestFiles,
-                affectedTestFiles: watchContext.affectedTestFiles
+                previousTestFiles: watchState.lastTestFiles,
+                affectedTestFiles: drainPendingAffectedTestFiles(watchState)
             });
-            watchContext.affectedTestFiles = [];
             if (rerunPlan.filesChanged) {
-                const deletedTestPaths = collectDeletedTestPaths(watchContext.lastTestFiles, rerunPlan.currentTestFiles);
+                const deletedTestPaths = collectDeletedTestPaths(watchState.lastTestFiles, rerunPlan.currentTestFiles);
                 if (deletedTestPaths.length > 0) context.updateReporterResultState([], [], deletedTestPaths);
-                watchContext.lastTestFiles = rerunPlan.currentTestFiles;
+                watchState.lastTestFiles = rerunPlan.currentTestFiles;
                 if (0 === rerunPlan.currentTestFiles.length) {
                     await latestRerunScheduler.enqueueLatest([]);
                     logger.log(color.cyan('No browser test files remain after update.\n'));
-                    logBrowserWatchReadyMessage(enableCliShortcuts);
+                    logWatchReadyMessage(context, enableCliShortcuts);
                     return;
                 }
                 logger.log(color.cyan(`Test file set changed, re-running ${rerunPlan.currentTestFiles.length} file(s)...\n`));
-                latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
+                await latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
                 return;
             }
             if (0 === rerunPlan.affectedTestFiles.length) {
                 logger.log(color.cyan('No affected browser test files detected, skipping re-run.\n'));
-                logBrowserWatchReadyMessage(enableCliShortcuts);
+                logWatchReadyMessage(context, enableCliShortcuts);
                 return;
             }
             logger.log(color.cyan(`Re-running ${rerunPlan.affectedTestFiles.length} affected test file(s)...\n`));
-            latestRerunScheduler.enqueueLatest(rerunPlan.affectedTestFiles);
+            await latestRerunScheduler.enqueueLatest(rerunPlan.affectedTestFiles);
         };
         const closeHeadlessRuntime = isWatchMode ? void 0 : async ()=>{
             sessionRegistry.clear();
@@ -4694,6 +4725,7 @@ const runBrowserController = async (context, options)=>{
         context.updateReporterResultState(reporterResults, caseResults);
         const isFailure = reporterResults.some((result)=>'fail' === result.status);
         if (isWatchMode && isFailure) ensureProcessExitCode(1);
+        const cycleCoverageMap = isWatchMode && coverageProvider ? buildBrowserCoverageMap(reporterResults, coverageProvider) : void 0;
         const result = {
             results: reporterResults,
             testResults: caseResults,
@@ -4701,18 +4733,21 @@ const runBrowserController = async (context, options)=>{
             hasFailure: isFailure,
             getSourcemap: getBrowserSourcemap,
             resolveSourcemap: resolveBrowserSourcemap,
-            close: closeHeadlessRuntime
+            close: closeHeadlessRuntime,
+            coverage: cycleCoverageMap,
+            watch: watchHandles
         };
         if (isWatchMode) try {
             await notifyTestRunEnd({
-                duration
+                duration,
+                coverage: cycleCoverageMap?.files().length ? cycleCoverageMap.toJSON() : void 0
             });
         } finally{
             await closeHeadlessRuntime?.();
         }
         if (isWatchMode && triggerRerun) {
-            watchContext.hooksEnabled = true;
-            logBrowserWatchReadyMessage(enableCliShortcuts);
+            watchState.hooksEnabled = true;
+            logWatchReadyMessage(context, enableCliShortcuts);
         }
         return result;
     }
@@ -4919,22 +4954,31 @@ const runBrowserController = async (context, options)=>{
         testTime = Date.now() - testStart;
     }
     if (isWatchMode) triggerRerun = async ()=>{
-        const newProjectEntries = await collectProjectEntries(context);
+        const refreshedHostOptions = {
+            ...hostOptions,
+            snapshot: {
+                updateSnapshot: context.snapshotManager.options.updateSnapshot
+            }
+        };
+        runtime.setContainerOptions(refreshedHostOptions);
+        const [, newProjectEntries] = await Promise.all([
+            rpcManager.updateHostConfig(refreshedHostOptions),
+            collectProjectEntries(context)
+        ]);
         const rerunPlan = planWatchRerun({
             projectEntries: newProjectEntries,
-            previousTestFiles: watchContext.lastTestFiles,
-            affectedTestFiles: watchContext.affectedTestFiles
+            previousTestFiles: watchState.lastTestFiles,
+            affectedTestFiles: drainPendingAffectedTestFiles(watchState)
         });
-        watchContext.affectedTestFiles = [];
         if (rerunPlan.filesChanged) {
-            const deletedTestPaths = collectDeletedTestPaths(watchContext.lastTestFiles, rerunPlan.currentTestFiles);
+            const deletedTestPaths = collectDeletedTestPaths(watchState.lastTestFiles, rerunPlan.currentTestFiles);
             if (deletedTestPaths.length > 0) context.updateReporterResultState([], [], deletedTestPaths);
-            watchContext.lastTestFiles = rerunPlan.currentTestFiles;
+            watchState.lastTestFiles = rerunPlan.currentTestFiles;
             currentTestFiles = rerunPlan.currentTestFiles;
             await rpcManager.notifyTestFileUpdate(currentTestFiles);
             if (0 === currentTestFiles.length) {
                 logger.log(color.cyan('No browser test files remain after update.\n'));
-                logBrowserWatchReadyMessage(enableCliShortcuts);
+                logWatchReadyMessage(context, enableCliShortcuts);
                 return;
             }
             await waitForRunnerFramesReady(currentTestFiles.map((file)=>file.testPath));
@@ -4954,25 +4998,21 @@ const runBrowserController = async (context, options)=>{
             } finally{
                 const testTime = Math.max(0, Date.now() - rerunStartTime);
                 const rerunFatalError = fatalError && fatalError !== fatalErrorBeforeRun ? fatalError : void 0;
-                await notifyTestRunEnd({
-                    duration: {
-                        totalTime: testTime,
-                        buildTime: 0,
-                        testTime
-                    },
-                    filterRerunTestPaths: rerunPlan.normalizedAffectedTestFiles,
+                await finalizeWatchRerun({
+                    rerunTestPaths: rerunPlan.normalizedAffectedTestFiles,
+                    testTime,
                     unhandledErrors: rerunError ? [
                         rerunError
                     ] : rerunFatalError ? [
                         rerunFatalError
                     ] : void 0
                 });
-                logBrowserWatchReadyMessage(enableCliShortcuts);
+                logWatchReadyMessage(context, enableCliShortcuts);
             }
-        } else if (rerunPlan.filesChanged) logBrowserWatchReadyMessage(enableCliShortcuts);
+        } else if (rerunPlan.filesChanged) logWatchReadyMessage(context, enableCliShortcuts);
         else {
             logger.log(color.cyan('Tests will be re-executed automatically\n'));
-            logBrowserWatchReadyMessage(enableCliShortcuts);
+            logWatchReadyMessage(context, enableCliShortcuts);
         }
     };
     const closeContainerRuntime = isWatchMode ? void 0 : async ()=>{
@@ -4993,6 +5033,7 @@ const runBrowserController = async (context, options)=>{
     context.updateReporterResultState(reporterResults, caseResults);
     const isFailure = reporterResults.some((result)=>'fail' === result.status);
     if (isWatchMode && isFailure) ensureProcessExitCode(1);
+    const cycleCoverageMap = isWatchMode && coverageProvider ? buildBrowserCoverageMap(reporterResults, coverageProvider) : void 0;
     const result = {
         results: reporterResults,
         testResults: caseResults,
@@ -5000,18 +5041,21 @@ const runBrowserController = async (context, options)=>{
         hasFailure: isFailure,
         getSourcemap: getBrowserSourcemap,
         resolveSourcemap: resolveBrowserSourcemap,
-        close: closeContainerRuntime
+        close: closeContainerRuntime,
+        coverage: cycleCoverageMap,
+        watch: watchHandles
     };
     if (isWatchMode) try {
         await notifyTestRunEnd({
-            duration
+            duration,
+            coverage: cycleCoverageMap?.files().length ? cycleCoverageMap.toJSON() : void 0
         });
     } finally{
         await closeContainerRuntime?.();
     }
     if (isWatchMode && triggerRerun) {
-        watchContext.hooksEnabled = true;
-        logBrowserWatchReadyMessage(enableCliShortcuts);
+        watchState.hooksEnabled = true;
+        logWatchReadyMessage(context, enableCliShortcuts);
     }
     return result;
 };
@@ -5204,7 +5248,7 @@ const emptyOutcome = ()=>({
         }
     });
 async function createBrowserExecutor(context, options) {
-    const { projects, coverageProvider, freezeShardedEntries, filesOnly, allowEmptyRun, appliedModifyRstestConfigEnvironments } = options;
+    const { projects, coverageProvider, shardedEntries, freezeShardedEntries, filesOnly, allowEmptyRun, appliedModifyRstestConfigEnvironments } = options;
     let deferredClose;
     let inFlightCycle;
     const foldOutcome = (result)=>{
@@ -5232,12 +5276,13 @@ async function createBrowserExecutor(context, options) {
         async runCycle (opts) {
             const cycle = runBrowserController(context, {
                 projects,
-                shardedEntries: opts.shardedEntries,
+                shardedEntries,
                 freezeShardedEntries,
                 allowEmptyRun,
                 appliedModifyRstestConfigEnvironments,
                 onTraceEvents: opts.onTraceEvents,
-                env: opts.env
+                env: opts.env,
+                updateSnapshot: opts.updateSnapshot
             });
             inFlightCycle = cycle;
             try {
@@ -5248,10 +5293,10 @@ async function createBrowserExecutor(context, options) {
                 inFlightCycle = void 0;
             }
         },
-        async collect (opts) {
+        async collect () {
             const pending = listBrowserTests(context, {
                 projects,
-                shardedEntries: opts.shardedEntries,
+                shardedEntries,
                 freezeShardedEntries,
                 filesOnly,
                 appliedModifyRstestConfigEnvironments