@rstest/browser 0.11.2 → 0.11.4

package/dist/index.js

@@ -1,4 +1,4 @@
-import { DEFAULT_TEST_TIMEOUT, PhaseTracker, RSTEST_ENV_SYMBOL_KEY, browserIgnoredRuntimeConfigKeys, buildBrowserCoverageMap, color, createCoverageProvider, createRunnerEventSink, createSilentConsoleController, getNoTestFilesMessage, getNumCpus as browser_getNumCpus, getSetupFiles, getTestEntries, hasUserRstestConfigPlugins, initModifyRstestConfigHooks, isDebug, isTTY, loadCoverageProvider, logger, 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);
+    }
+    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);
     }
-    watchContext.chunkHashes = currentHashes;
-    return Array.from(affectedFiles);
+    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)=>({
@@ -3332,12 +3333,29 @@ const generateManifestModule = ({ manifestPath, entries, isWatchMode })=>{
         if (isWatchMode) {
             const includeRegExp = globPatternsToRegExp(project.normalizedConfig.include);
             const excludeRegExp = createBrowserContextExcludeRegExp(project.normalizedConfig.exclude.patterns, projectRootPosix);
-            lines.push(`const ${varName} = import.meta.webpackContext(${JSON.stringify(projectRootPosix)}, {`);
-            lines.push('  recursive: true,');
-            lines.push(`  regExp: ${includeRegExp.toString()},`);
-            if (excludeRegExp) lines.push(`  exclude: ${excludeRegExp.toString()},`);
-            lines.push("  mode: 'lazy',");
-            lines.push('});');
+            const { includeSource } = project.normalizedConfig;
+            const emitContext = (contextVarName, regExp)=>{
+                lines.push(`const ${contextVarName} = import.meta.webpackContext(${JSON.stringify(projectRootPosix)}, {`);
+                lines.push('  recursive: true,');
+                lines.push(`  regExp: ${regExp.toString()},`);
+                if (excludeRegExp) lines.push(`  exclude: ${excludeRegExp.toString()},`);
+                lines.push("  mode: 'lazy',");
+                lines.push('});');
+            };
+            if (0 === includeSource.length) emitContext(varName, includeRegExp);
+            else {
+                emitContext(`${varName}_include`, includeRegExp);
+                emitContext(`${varName}_source`, globPatternsToRegExp(includeSource));
+                const probedKeys = testFiles.map((filePath)=>toContextKey(filePath, projectRootPosix));
+                lines.push(`const ${varName}_probed = ${JSON.stringify(probedKeys)};`);
+                lines.push(`const ${varName}_includeKeys = new Set(${varName}_include.keys());`);
+                lines.push(`const ${varName} = Object.assign(`);
+                lines.push(`  (key) => ${varName}_includeKeys.has(key) ? ${varName}_include(key) : ${varName}_source(key),`);
+                lines.push('  {');
+                lines.push(`    keys: () => Array.from(new Set([...${varName}_includeKeys, ...${varName}_probed])),`);
+                lines.push('  },');
+                lines.push(');');
+            }
         } else {
             lines.push(`const ${varName}_modules = {`);
             for (const filePath of testFiles){
@@ -3409,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;
@@ -3442,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];
@@ -3464,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);
@@ -3493,7 +3508,6 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
     };
     const browserRuntimePath = fileURLToPath(import.meta.resolve('@rstest/core/internal/browser-runtime'));
     const staticRstestAliases = {
-        '@rstest/core': resolveBrowserFile('client/public.ts'),
         '@rstest/browser': resolveBrowserFile('browser.ts'),
         '@rstest/core/internal/browser-runtime': browserRuntimePath
     };
@@ -3589,6 +3603,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
             appliedEnvironmentNames: appliedModifyRstestConfigEnvironments
         });
         rsbuildInstance.addPlugins([
+            pluginMockRuntime,
             {
                 name: 'rstest:browser-user-config',
                 setup (api) {
@@ -3619,18 +3634,33 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                                 source: {
                                     define: {
                                         'process.env': rstestEnvDefine,
-                                        'import.meta.env': rstestEnvDefine
+                                        'import.meta.env': rstestEnvDefine,
+                                        'import.meta.rstest': importMetaRstestDefine('web')
                                     }
                                 },
                                 output: {
                                     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, {
+                                            rspack: rspack,
+                                            rootPath: project.rootPath
+                                        });
                                         rspackConfig.lazyCompilation = enableHmr ? createBrowserLazyCompilationConfig(setupFiles) : false;
                                         rspackConfig.plugins = rspackConfig.plugins || [];
                                         rspackConfig.plugins.push(virtualManifestPlugin);
@@ -3663,21 +3693,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();
                     });
                 }
@@ -3710,6 +3765,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,
@@ -3822,7 +3878,8 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
             setContainerOptions,
             dispatchHandlers,
             wss,
-            projectEntries
+            projectEntries,
+            watchState
         };
     } catch (error) {
         wss.close();
@@ -4012,12 +4069,12 @@ const runBrowserController = async (context, options)=>{
         if (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({
@@ -4046,12 +4103,63 @@ 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);
+        let sessionCoverage;
+        const coverageMap = buildBrowserCoverageMap(context.reporterResults.results, coverageProvider, {
+            keepResultCoverage: true
+        });
+        if (coverageMap && coverageMap.files().length > 0) sessionCoverage = coverageMap.toJSON();
+        const outcome = {
+            results: context.reporterResults.results.filter((result)=>rerunPathSet.has(result.testPath)),
+            testResults: context.reporterResults.testResults.filter((result)=>rerunPathSet.has(result.testPath)),
+            errors: unhandledErrors ?? [],
+            testPaths: rerunTestPaths,
+            duration: {
+                buildTime: drainPendingBuildTime(watchState),
+                testTime
+            },
+            coverage: sessionCoverage ? {
+                map: sessionCoverage
+            } : 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;
@@ -4098,7 +4206,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,
@@ -4272,7 +4380,7 @@ const runBrowserController = async (context, options)=>{
     const handleLog = async (payload)=>{
         const log = {
             content: payload.content,
-            name: payload.level,
+            name: getPrettyConsoleName(payload.level),
             taskId: payload.taskId,
             taskName: payload.taskName,
             taskParentNames: payload.taskParentNames,
@@ -4439,6 +4547,9 @@ const runBrowserController = async (context, options)=>{
                 });
                 const inlineOptions = {
                     ...hostOptions,
+                    snapshot: {
+                        updateSnapshot: context.snapshotManager.options.updateSnapshot
+                    },
                     testFile: file.testPath,
                     runId: `${run.token}:${session.id}`
                 };
@@ -4551,20 +4662,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)=>{
@@ -4578,6 +4685,7 @@ const runBrowserController = async (context, options)=>{
                 logger.debug(`[Headless] Interrupting active run token ${run.token} before scheduling latest rerun`);
             }
         });
+        awaitHeadlessRerunIdle = ()=>latestRerunScheduler.whenIdle();
         if (0 === allTestFiles.length) {
             const duration = {
                 totalTime: buildTime,
@@ -4594,7 +4702,8 @@ const runBrowserController = async (context, options)=>{
                 close: isWatchMode ? void 0 : async ()=>{
                     sessionRegistry.clear();
                     await destroyBrowserRuntime(runtime);
-                }
+                },
+                watch: watchHandles
             };
             if (isWatchMode) await notifyTestRunEnd({
                 duration
@@ -4604,25 +4713,24 @@ 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) {
-                        watchContext.lastTestFiles = rerunPlan.currentTestFiles;
+                        watchState.lastTestFiles = rerunPlan.currentTestFiles;
                         if (0 === rerunPlan.currentTestFiles.length) {
                             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;
                     }
-                    logBrowserWatchReadyMessage(enableCliShortcuts);
+                    logWatchReadyMessage(context, enableCliShortcuts);
                 };
-                watchContext.hooksEnabled = true;
-                logBrowserWatchReadyMessage(enableCliShortcuts);
+                watchState.hooksEnabled = true;
+                logWatchReadyMessage(context, enableCliShortcuts);
             }
             return result;
         }
@@ -4633,31 +4741,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();
@@ -4679,7 +4786,8 @@ const runBrowserController = async (context, options)=>{
             hasFailure: isFailure,
             getSourcemap: getBrowserSourcemap,
             resolveSourcemap: resolveBrowserSourcemap,
-            close: closeHeadlessRuntime
+            close: closeHeadlessRuntime,
+            watch: watchHandles
         };
         if (isWatchMode) try {
             await notifyTestRunEnd({
@@ -4689,8 +4797,8 @@ const runBrowserController = async (context, options)=>{
             await closeHeadlessRuntime?.();
         }
         if (isWatchMode && triggerRerun) {
-            watchContext.hooksEnabled = true;
-            logBrowserWatchReadyMessage(enableCliShortcuts);
+            watchState.hooksEnabled = true;
+            logWatchReadyMessage(context, enableCliShortcuts);
         }
         return result;
     }
@@ -4897,22 +5005,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));
@@ -4932,25 +5049,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 ()=>{
@@ -4978,7 +5091,8 @@ const runBrowserController = async (context, options)=>{
         hasFailure: isFailure,
         getSourcemap: getBrowserSourcemap,
         resolveSourcemap: resolveBrowserSourcemap,
-        close: closeContainerRuntime
+        close: closeContainerRuntime,
+        watch: watchHandles
     };
     if (isWatchMode) try {
         await notifyTestRunEnd({
@@ -4988,8 +5102,8 @@ const runBrowserController = async (context, options)=>{
         await closeContainerRuntime?.();
     }
     if (isWatchMode && triggerRerun) {
-        watchContext.hooksEnabled = true;
-        logBrowserWatchReadyMessage(enableCliShortcuts);
+        watchState.hooksEnabled = true;
+        logWatchReadyMessage(context, enableCliShortcuts);
     }
     return result;
 };
@@ -5182,7 +5296,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)=>{
@@ -5210,12 +5324,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 {
@@ -5226,10 +5341,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