@rstest/browser 0.11.6 → 0.11.8

package/dist/index.js

@@ -1,15 +1,16 @@
-import { DEFAULT_TEST_TIMEOUT, FATAL_SIGNALS, PhaseTracker, RSTEST_ENV_SYMBOL_KEY, applyWatchInvalidation, applyWebMockRspackConfig, browserIgnoredRuntimeConfigKeys, buildBrowserCoverageMap, color, createCoverageProvider, createRunnerEventSink, createSilentConsoleController, getNumCpus as browser_getNumCpus, getPrettyConsoleName, getSetupFiles, getTestEntries, hasUserRstestConfigPlugins, importMetaRstestDefine, initModifyRstestConfigHooks, isDebug, isTTY, loadCoverageProvider, logWatchReadyMessage, logger, pluginMockRuntime, projectRuntimeConfig, resolveProjectBuildCache, resolveShardedEntries, resolveSnapshotPathDefault, resolveWorkerCount, rsbuild, serializableConfig } from "@rstest/core/internal/browser";
+import { DEFAULT_TEST_TIMEOUT, FATAL_SIGNALS, FIXTURE_CLEANUP_TIMEOUT_MS, PhaseTracker, RSTEST_ENV_SYMBOL_KEY, applyWatchInvalidation, applyWebMockRspackConfig, browserIgnoredRuntimeConfigKeys, buildBrowserCoverageMap, color, createCoverageProvider, createFileCleanupTimeoutResult, createRunnerEventSink, createSilentConsoleController, getNumCpus as browser_getNumCpus, getPrettyConsoleName, getSetupFiles, getTestEntries, hasUserRstestConfigPlugins, initModifyRstestConfigHooks, isDebug, isTTY, loadCoverageProvider, logWatchReadyMessage, logger, pluginMockRuntime, projectRuntimeConfig, resolveProjectBuildCache, resolveShardedEntries, resolveSnapshotPathDefault, resolveWorkerCount, rsbuild, serializableConfig } from "@rstest/core/internal/browser";
 import promises from "node:fs/promises";
-import { dirname, join, normalize, relative, resolve as external_pathe_resolve } from "pathe";
+import { dirname, isAbsolute as external_pathe_isAbsolute, join, normalize, relative, resolve as external_pathe_resolve } from "pathe";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
 import open_editor from "open-editor";
 import sirv from "sirv";
 import { WebSocketServer } from "ws";
+import { AnyMap, TraceMap, encodedMap } from "@jridgewell/trace-mapping";
 import convert_source_map from "convert-source-map";
-import { __webpack_require__ } from "./rslib-runtime.js";
-import { DISPATCH_RPC_BRIDGE_NAME, DISPATCH_NAMESPACE_SNAPSHOT, DISPATCH_MESSAGE_TYPE, DISPATCH_NAMESPACE_BROWSER } from "./33.js";
+import { randomUUID } from "node:crypto";
+import { __webpack_require__ } from "./612~0.js";
 __webpack_require__.add({
     "../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         const pico = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/lib/picomatch.js");
@@ -1702,6 +1703,12 @@ class HostDispatchRouter {
         }
     }
 }
+const DISPATCH_MESSAGE_TYPE = '__rstest_dispatch__';
+const DISPATCH_RPC_BRIDGE_NAME = '__rstest_dispatch_rpc__';
+const DISPATCH_NAMESPACE_BROWSER = 'browser';
+const DISPATCH_NAMESPACE_FILE_CLEANUP = 'file-cleanup';
+const DISPATCH_NAMESPACE_SNAPSHOT = 'snapshot';
+const RSTEST_BROWSER_CACHE_CLEANERS_KEY = '@rstest/browser/cache-cleaners';
 const snapshotRequestBuilders = {
     resolveSnapshotPath: (id, args)=>({
             id,
@@ -1842,11 +1849,6 @@ 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."
@@ -1897,8 +1899,9 @@ const reportUnsupportedBrowserOptions = (context)=>{
     const globalConfig = context.normalizedConfig;
     const { coverage } = globalConfig;
     if ('list' !== context.command && coverage.enabled && 'v8' === coverage.provider) {
-        if (isBrowserOnlyRun) throw new Error("Coverage provider 'v8' is not supported in browser mode: browser projects produce no v8 coverage. Use the default istanbul provider (coverage.provider: 'istanbul') for browser coverage.");
-        logger.warn(color.yellow("Coverage provider 'v8' produces no coverage for browser project files; use the 'istanbul' provider to collect browser coverage. Node projects will still use v8."));
+        const unsupportedProject = browserProjects.find((project)=>'chromium' !== project.normalizedConfig.browser.browser);
+        if (unsupportedProject) if (isBrowserOnlyRun) throw new Error(`Coverage provider 'v8' in browser mode requires Chromium. Project ${JSON.stringify(unsupportedProject.name)} uses ${JSON.stringify(unsupportedProject.normalizedConfig.browser.browser)}. Use Chromium or coverage.provider: 'istanbul'.`);
+        else logger.warn(color.yellow(`Coverage provider 'v8' requires Chromium for browser project ${JSON.stringify(unsupportedProject.name)}. Its files will not produce coverage; node projects will still use v8.`));
     }
     const warnings = new Set();
     if ('forks' !== globalConfig.pool.type) warnings.add(`Ignoring pool.type '${globalConfig.pool.type}' in browser mode.`);
@@ -2350,6 +2353,17 @@ async function launchPlaywrightBrowser({ browserName, headless, providerOptions
         browser: wrappedBrowser
     };
 }
+const asCoveragePage = (page)=>page;
+const createPlaywrightV8CoverageCollector = ()=>({
+        async start (page) {
+            await asCoveragePage(page).coverage.startJSCoverage({
+                resetOnNavigation: false
+            });
+        },
+        async take (page) {
+            return asCoveragePage(page).coverage.stopJSCoverage();
+        }
+    });
 const playwrightProviderImplementation = {
     name: 'playwright',
     async launchRuntime ({ browserName, headless, providerOptions }) {
@@ -2359,6 +2373,9 @@ const playwrightProviderImplementation = {
             providerOptions
         });
     },
+    createV8CoverageCollector ({ browserName }) {
+        return 'chromium' === browserName ? createPlaywrightV8CoverageCollector() : null;
+    },
     async dispatchRpc ({ containerPage, runnerPage, request, timeoutFallbackMs }) {
         return dispatchPlaywrightBrowserRpc({
             containerPage: containerPage,
@@ -2376,15 +2393,18 @@ function getBrowserProviderImplementation(provider) {
     if (!implementation) throw new Error(`Unsupported browser provider: ${String(provider)}`);
     return implementation;
 }
-const collectDeletedTestPaths = (previous, current)=>{
-    const currentPathSet = new Set(current.map((file)=>file.testPath));
-    return previous.map((file)=>file.testPath).filter((testPath)=>!currentPathSet.has(testPath));
-};
 const serializeTestFiles = (files)=>JSON.stringify(files.map((f)=>`${f.projectName}:${f.testPath}`).sort());
 const normalizeTestFiles = (files)=>files.map((file)=>({
             ...file,
             testPath: normalize(file.testPath)
         }));
+const collectTestPaths = (files)=>[
+        ...new Set(files.map((file)=>file.testPath))
+    ];
+const collectDeletedTestPaths = (previous, current)=>{
+    const currentPathSet = new Set(current.map((file)=>file.testPath));
+    return previous.map((file)=>file.testPath).filter((testPath)=>!currentPathSet.has(testPath));
+};
 const collectWatchTestFiles = (projectEntries)=>projectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
                 testPath: normalize(testPath),
                 projectName: entry.project.name
@@ -2392,23 +2412,88 @@ const collectWatchTestFiles = (projectEntries)=>projectEntries.flatMap((entry)=>
 const planWatchRerun = ({ projectEntries, previousTestFiles, affectedTestFiles })=>{
     const currentTestFiles = collectWatchTestFiles(projectEntries);
     const normalizedPrevious = normalizeTestFiles(previousTestFiles);
-    const filesChanged = serializeTestFiles(currentTestFiles) !== serializeTestFiles(normalizedPrevious);
-    const normalizedAffectedTestFiles = affectedTestFiles.map((testFile)=>normalize(testFile));
-    const affectedPathSet = new Set(normalizedAffectedTestFiles);
-    const matchedAffectedFiles = currentTestFiles.filter((file)=>affectedPathSet.has(file.testPath));
+    const fileSetChanged = serializeTestFiles(currentTestFiles) !== serializeTestFiles(normalizedPrevious);
+    if (fileSetChanged) {
+        const fileSetUpdate = {
+            currentTestFiles,
+            deletedTestPaths: collectDeletedTestPaths(normalizedPrevious, currentTestFiles)
+        };
+        if (0 === currentTestFiles.length) return {
+            fileSetUpdate,
+            decision: {
+                kind: 'empty',
+                message: 'No browser test files remain after update.\n'
+            }
+        };
+        return {
+            fileSetUpdate,
+            decision: {
+                kind: 'rerun',
+                testPaths: collectTestPaths(currentTestFiles),
+                message: `Test file set changed, re-running ${currentTestFiles.length} file(s)...\n`
+            }
+        };
+    }
+    const affectedPathSet = new Set(affectedTestFiles.map((testFile)=>normalize(testFile)));
+    const matchedAffectedFiles = currentTestFiles.filter(({ testPath })=>affectedPathSet.has(testPath));
+    if (0 === matchedAffectedFiles.length) return {
+        decision: {
+            kind: 'idle',
+            message: 'No affected browser test files detected, skipping re-run.\n'
+        }
+    };
     return {
-        currentTestFiles,
-        filesChanged,
-        normalizedAffectedTestFiles,
-        affectedTestFiles: matchedAffectedFiles
+        decision: {
+            kind: 'rerun',
+            testPaths: collectTestPaths(matchedAffectedFiles),
+            message: `Re-running ${matchedAffectedFiles.length} affected test file(s)...\n`
+        }
     };
 };
+const commitWatchFileSetUpdate = (update, watchState, pruneDeletedTestPaths)=>{
+    if (!update) return;
+    if (update.deletedTestPaths.length > 0) pruneDeletedTestPaths(update.deletedTestPaths);
+    watchState.lastTestFiles = update.currentTestFiles;
+};
 const picomatch = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.5/node_modules/picomatch/index.js");
 var picomatch_default = /*#__PURE__*/ __webpack_require__.n(picomatch);
 const { createRsbuild: createRsbuild, rspack: rspack } = rsbuild;
 const browserRsbuild_dirname = dirname(fileURLToPath(import.meta.url));
 const OPTIONS_PLACEHOLDER = '__RSTEST_OPTIONS_PLACEHOLDER__';
 const serializeForInlineScript = (value)=>JSON.stringify(value).replace(/</g, '\\u003c').replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+class RstestBrowserRuntimePlugin {
+    apply(compiler) {
+        const { RuntimeModule } = compiler.webpack;
+        class BrowserRuntimeModule extends RuntimeModule {
+            constructor(){
+                super('rstest_browser_runtime');
+            }
+            generate() {
+                return `
+var __rstest_browser_test_entry_ids__ = Object.create(null);
+
+__webpack_require__.rstest_register_browser_test_entry = (path, id) => {
+  __rstest_browser_test_entry_ids__[path] = id;
+};
+
+function __rstest_clean_browser_test_entry__(testEntryPath) {
+  var testEntryId = __rstest_browser_test_entry_ids__[testEntryPath];
+  if (testEntryId !== undefined) {
+    delete __webpack_module_cache__[testEntryId];
+  }
+}
+
+(globalThis[${JSON.stringify(RSTEST_BROWSER_CACHE_CLEANERS_KEY)}] ??= new Set()).add(__rstest_clean_browser_test_entry__);
+`;
+            }
+        }
+        compiler.hooks.thisCompilation.tap('RstestBrowserRuntimePlugin', (compilation)=>{
+            compilation.hooks.additionalTreeRuntimeRequirements.tap('RstestAddBrowserRuntimePlugin', (chunk)=>{
+                compilation.addRuntimeModule(chunk, new BrowserRuntimeModule());
+            });
+        });
+    }
+}
 const getBrowserProviderOptions = (project)=>{
     const browserConfig = project.normalizedConfig.browser;
     return browserConfig.providerOptions ?? {};
@@ -2416,6 +2501,7 @@ const getBrowserProviderOptions = (project)=>{
 const createBrowserWatchState = ()=>({
         lastTestFiles: [],
         hooksEnabled: false,
+        headedFileSetVersion: 1,
         invalidation: new Map(),
         pendingAffectedTestFiles: new Map(),
         compileStartTimes: new Map(),
@@ -2688,13 +2774,13 @@ const browserRsbuild_collectProjectEntries = async (context, browserProjects = g
             testFiles: Object.values(tests)
         };
     }));
-const resolveBrowserFile = (relativePath)=>{
+const resolveBrowserDistFile = (relativePath)=>{
     const candidates = [
-        external_pathe_resolve(browserRsbuild_dirname, '../src', relativePath),
-        external_pathe_resolve(browserRsbuild_dirname, relativePath)
+        external_pathe_resolve(browserRsbuild_dirname, relativePath),
+        external_pathe_resolve(browserRsbuild_dirname, '../dist', relativePath)
     ];
     for (const candidate of candidates)if (existsSync(candidate)) return candidate;
-    throw new Error(`Unable to resolve browser client file: ${relativePath}`);
+    throw new Error(`Unable to resolve browser dist file: ${relativePath}`);
 };
 const resolveContainerDist = ()=>{
     const distPath = external_pathe_resolve(browserRsbuild_dirname, 'browser-container');
@@ -2839,7 +2925,7 @@ const destroyBrowserRuntime = async (runtime)=>{
         force: true
     }).catch(()=>{});
 };
-const createBrowserRuntime = async ({ context, projectEntries: initialProjectEntries, browserProjects, shardedEntries, freezeShardedEntries, tempDir, isWatchMode, onTriggerRerun, containerDistPath, containerDevServer, forceHeadless, skipProviderLaunch, appliedModifyRstestConfigEnvironments })=>{
+const createBrowserRuntime = async ({ context, projectEntries: initialProjectEntries, browserProjects, shardedEntries, freezeShardedEntries, tempDir, isWatchMode, containerDistPath, containerDevServer, forceHeadless, skipProviderLaunch, appliedModifyRstestConfigEnvironments })=>{
     const containerHtmlTemplate = containerDistPath ? await promises.readFile(join(containerDistPath, 'index.html'), 'utf-8') : null;
     let injectedContainerHtml = null;
     let serializedOptions = 'null';
@@ -2903,7 +2989,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
     };
     const browserRuntimePath = fileURLToPath(import.meta.resolve('@rstest/core/internal/browser-runtime'));
     const staticRstestAliases = {
-        '@rstest/browser': resolveBrowserFile('browser.ts'),
+        '@rstest/browser': resolveBrowserDistFile('client/index.js'),
         '@rstest/core/internal/browser-runtime': browserRuntimePath
     };
     const rstestEnvDefine = `globalThis[Symbol.for(${JSON.stringify(RSTEST_ENV_SYMBOL_KEY)})]`;
@@ -2991,7 +3077,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
             modules: virtualManifestModules
         });
         const rstestInternalAliases = {
-            '@rstest/browser-manifest': manifestPath,
+            __rstest_virtual_browser_manifest__: manifestPath,
             ...staticRstestAliases
         };
         const isHeadless = forceHeadless || project.normalizedConfig.browser.headless;
@@ -3029,6 +3115,17 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
             {
                 name: 'rstest:browser-user-config',
                 setup (api) {
+                    if ('list' === context.command) {
+                        let testEntryPaths;
+                        const getTestEntryPaths = ()=>testEntryPaths ??= new Set(getProjectEntry(project)?.testFiles.map(normalize) ?? []);
+                        api.transform({
+                            test: (resourcePath)=>getTestEntryPaths().has(normalize(resourcePath))
+                        }, ({ code, resourcePath })=>({
+                                code: `${code}\nif (__webpack_require__.rstest_register_browser_test_entry && __webpack_module__.id != null) {
+  __webpack_require__.rstest_register_browser_test_entry(${JSON.stringify(normalize(resourcePath))}, __webpack_module__.id);
+}`
+                            }));
+                    }
                     api.expose?.('rstest:browser', {
                         registerDispatchHandler: (namespace, handler)=>{
                             dispatchHandlers.set(namespace, handler);
@@ -3056,8 +3153,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                                 source: {
                                     define: {
                                         'process.env': rstestEnvDefine,
-                                        'import.meta.env': rstestEnvDefine,
-                                        'import.meta.rstest': importMetaRstestDefine('web')
+                                        'import.meta.env': rstestEnvDefine
                                     }
                                 },
                                 output: {
@@ -3085,6 +3181,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                                         });
                                         rspackConfig.lazyCompilation = enableHmr ? createBrowserLazyCompilationConfig(setupFiles) : false;
                                         rspackConfig.plugins = rspackConfig.plugins || [];
+                                        rspackConfig.plugins.push(new RstestBrowserRuntimePlugin());
                                         rspackConfig.plugins.push(virtualManifestPlugin);
                                         applyDefaultWatchOptions(rspackConfig, isWatchMode);
                                         const browserRuntimeDir = dirname(browserRuntimePath);
@@ -3101,7 +3198,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                             });
                             merged.source = merged.source || {};
                             merged.source.entry = {
-                                runner: resolveBrowserFile('client/entry.ts')
+                                runner: resolveBrowserDistFile('client/runner.js')
                             };
                             return merged;
                         },
@@ -3110,7 +3207,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                 }
             }
         ]);
-        if (isWatchMode && onTriggerRerun) rsbuildInstance.addPlugins([
+        if (isWatchMode) rsbuildInstance.addPlugins([
             {
                 name: 'rstest:browser-watch',
                 setup (api) {
@@ -3155,7 +3252,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                             }
                         }
                         if (!watchState.hooksEnabled) return;
-                        await onTriggerRerun();
+                        await watchState.triggerRerun?.();
                     });
                 }
             }
@@ -3306,8 +3403,182 @@ async function resolveProjectEntries(context, shardedEntries, browserProjects) {
     }
     return browserRsbuild_collectProjectEntries(context, browserProjects);
 }
-const TYPE_REQUEST = "q";
-const TYPE_RESPONSE = "s";
+const flattenSourceMap = (sourceMap, sourceMapUrl)=>encodedMap(new AnyMap(sourceMap, sourceMapUrl));
+const normalizeJavaScriptUrl = (value, options)=>{
+    try {
+        const url = options?.origin ? new URL(value, options.origin) : new URL(value);
+        if ('http:' !== url.protocol && 'https:' !== url.protocol) return null;
+        url.hash = '';
+        return url.toString();
+    } catch  {
+        return null;
+    }
+};
+const resolveInlineSourceMap = (code, sourceMapUrl)=>{
+    try {
+        const converter = convert_source_map.fromSource(code);
+        return converter ? flattenSourceMap(converter.toObject(), sourceMapUrl) : null;
+    } catch  {
+        return null;
+    }
+};
+const loadSourceMapForSource = async ({ jsUrl, signal, source, fetcher = fetch })=>{
+    const normalizedUrl = normalizeJavaScriptUrl(jsUrl);
+    if (!normalizedUrl) return null;
+    try {
+        const matches = [
+            ...source.matchAll(convert_source_map.mapFileCommentRegex)
+        ];
+        const finalMatch = matches.at(-1);
+        const sourceMapUrl = finalMatch?.[1] ?? finalMatch?.[2]?.trim();
+        if (!sourceMapUrl || sourceMapUrl.startsWith('data:')) return null;
+        const resolvedSourceMapUrl = new URL(sourceMapUrl, normalizedUrl);
+        if ('http:' !== resolvedSourceMapUrl.protocol && 'https:' !== resolvedSourceMapUrl.protocol) return null;
+        const mapResponse = await fetcher(resolvedSourceMapUrl.href, signal ? {
+            signal
+        } : void 0);
+        return mapResponse.ok ? {
+            sourceMap: flattenSourceMap(await mapResponse.json(), resolvedSourceMapUrl.href),
+            sourceMapUrl: resolvedSourceMapUrl.href
+        } : null;
+    } catch  {
+        return null;
+    }
+};
+const fetchSourceMap = async (jsUrl, fetcher)=>{
+    const jsResponse = await fetcher(jsUrl);
+    if (!jsResponse.ok) return null;
+    const code = await jsResponse.text();
+    const inlineMap = resolveInlineSourceMap(code, jsUrl);
+    if (inlineMap) return inlineMap;
+    const mapUrl = new URL(jsUrl);
+    mapUrl.pathname += '.map';
+    const mapResponse = await fetcher(mapUrl.href);
+    if (!mapResponse.ok) return null;
+    return flattenSourceMap(await mapResponse.json(), mapUrl.href);
+};
+const loadSourceMapWithCache = async ({ jsUrl, cache, force = false, origin, fetcher = fetch })=>{
+    const normalizedUrl = normalizeJavaScriptUrl(jsUrl, {
+        origin
+    });
+    if (!normalizedUrl) return null;
+    if (!force && cache.has(normalizedUrl)) return cache.get(normalizedUrl) ?? null;
+    try {
+        const sourceMap = await fetchSourceMap(normalizedUrl, fetcher);
+        cache.set(normalizedUrl, sourceMap);
+        return sourceMap;
+    } catch  {
+        cache.set(normalizedUrl, null);
+        return null;
+    }
+};
+const resolveCoverageResourceUrl = (value)=>{
+    try {
+        const url = new URL(value);
+        return 'http:' === url.protocol || 'https:' === url.protocol ? url.href : null;
+    } catch  {
+        return null;
+    }
+};
+const resolveProjectHttpSource = (source, rootPath, projectOrigin)=>{
+    let sourceUrl;
+    try {
+        sourceUrl = new URL(source);
+    } catch  {
+        return source;
+    }
+    if ('http:' !== sourceUrl.protocol && 'https:' !== sourceUrl.protocol || sourceUrl.origin !== projectOrigin) return source;
+    let sourcePath = sourceUrl.pathname;
+    try {
+        sourcePath = decodeURIComponent(sourcePath);
+    } catch  {}
+    return external_pathe_resolve(rootPath, sourcePath.replace(/^\/+/, ''));
+};
+const normalizeSourceMap = (sourceMap, rootPath, sourceMapUrl, scriptOrigin, projectOrigin)=>{
+    const webpackSourceRoot = 'string' == typeof sourceMap.sourceRoot && sourceMap.sourceRoot.startsWith('webpack:') ? sourceMap.sourceRoot : void 0;
+    const resolvedSources = new TraceMap(sourceMap, sourceMapUrl).resolvedSources;
+    const { sourceRoot: _, ...sourceMapWithoutRoot } = sourceMap;
+    return {
+        ...sourceMapWithoutRoot,
+        sources: sourceMap.sources.map((source, index)=>{
+            if ('string' != typeof source) return source;
+            if ('rstest runtime' === source || source.startsWith('webpack/runtime/') || source.startsWith('data:') || source.startsWith('blob:')) return source;
+            if (external_pathe_isAbsolute(source)) return source;
+            let sourceUrl;
+            try {
+                sourceUrl = webpackSourceRoot ? new URL(source, webpackSourceRoot) : new URL(source);
+            } catch  {
+                const resolvedSource = resolvedSources[index] ?? source;
+                return resolveProjectHttpSource(resolvedSource, rootPath, projectOrigin);
+            }
+            if ('webpack:' !== sourceUrl.protocol) {
+                const resolvedSource = resolvedSources[index] ?? source;
+                return resolveProjectHttpSource(resolvedSource, rootPath, projectOrigin);
+            }
+            let sourcePath = sourceUrl.pathname;
+            try {
+                sourcePath = decodeURIComponent(sourcePath);
+            } catch  {}
+            sourcePath = sourcePath.replace(/^\/+/, '');
+            if ('rstest runtime' === sourcePath || sourcePath.startsWith('data:') || sourcePath.startsWith('blob:')) return sourcePath;
+            if (sourcePath.startsWith('webpack/runtime/')) return source;
+            return scriptOrigin === projectOrigin ? external_pathe_resolve(rootPath, sourcePath) : new URL(sourcePath, `${scriptOrigin}/`).href;
+        })
+    };
+};
+const takeBrowserV8Coverage = async ({ collector, page, projectUrl, rootPath, fetchTimeout, sourceMapCache, resourceStore })=>{
+    const rawEntries = await collector.take(page);
+    const projectOrigin = new URL(projectUrl).origin;
+    const entries = [];
+    const assetFiles = {};
+    const sourceMaps = {};
+    await Promise.all(rawEntries.map(async (entry)=>{
+        const url = resolveCoverageResourceUrl(entry.url);
+        const cacheUrl = normalizeJavaScriptUrl(entry.url);
+        if (!url || !cacheUrl || !entry.source) return;
+        const inlineSourceMap = resolveInlineSourceMap(entry.source, url);
+        const loadedSourceMap = inlineSourceMap ? null : await loadSourceMapForSource({
+            jsUrl: url,
+            signal: fetchTimeout > 0 ? AbortSignal.timeout(fetchTimeout) : void 0,
+            source: entry.source
+        });
+        const sourceMap = inlineSourceMap ?? loadedSourceMap?.sourceMap;
+        const normalizedSourceMap = sourceMap ? normalizeSourceMap(sourceMap, rootPath, loadedSourceMap?.sourceMapUrl ?? url, new URL(url).origin, projectOrigin) : void 0;
+        const filePath = url;
+        entries.push({
+            url,
+            scriptId: entry.scriptId,
+            filePath,
+            functions: entry.functions
+        });
+        if (resourceStore?.assetFiles.get(filePath) !== entry.source) {
+            assetFiles[filePath] = entry.source;
+            resourceStore?.assetFiles.set(filePath, entry.source);
+        }
+        if (normalizedSourceMap) {
+            sourceMapCache.set(cacheUrl, normalizedSourceMap);
+            const serializedSourceMap = JSON.stringify(normalizedSourceMap);
+            if (resourceStore?.sourceMaps.get(filePath) !== serializedSourceMap) {
+                sourceMaps[filePath] = serializedSourceMap;
+                resourceStore?.sourceMaps.set(filePath, serializedSourceMap);
+            }
+        } else {
+            sourceMapCache.delete(cacheUrl);
+            resourceStore?.sourceMaps.delete(filePath);
+        }
+    }));
+    if (!entries.length) return null;
+    return {
+        entries,
+        ...Object.keys(assetFiles).length || Object.keys(sourceMaps).length ? {
+            options: {
+                assetFiles,
+                sourceMaps
+            }
+        } : {},
+        root: rootPath
+    };
+};
 function createPromiseWithResolvers() {
     let resolve;
     let reject;
@@ -3343,7 +3614,7 @@ function createBirpc($functions, options) {
         const req = {
             m: method,
             a: args,
-            t: TYPE_REQUEST
+            t: "q"
         };
         if (optional) req.o = true;
         const send = async (_req)=>post(serialize(_req));
@@ -3394,7 +3665,7 @@ function createBirpc($functions, options) {
         $call: (method, ...args)=>_call(method, args, false),
         $callOptional: (method, ...args)=>_call(method, args, false, true),
         $callEvent: (method, ...args)=>_call(method, args, true),
-        $callRaw: (options$1)=>_call(options$1.method, options$1.args, options$1.event, options$1.optional),
+        $callRaw: (options)=>_call(options.method, options.args, options.event, options.optional),
         $rejectPendingCalls,
         get $closed () {
             return $closed;
@@ -3407,7 +3678,7 @@ function createBirpc($functions, options) {
     };
     rpc = proxify ? new Proxy({}, {
         get (_, method) {
-            if (Object.prototype.hasOwnProperty.call(builtinMethods, method)) return builtinMethods[method];
+            if (Object.hasOwn(builtinMethods, method)) return builtinMethods[method];
             if ("then" === method && !eventNames.includes("then") && !("then" in $functions)) return;
             const sendEvent = (...args)=>_call(method, args, true);
             if (eventNames.includes(method)) {
@@ -3451,7 +3722,7 @@ function createBirpc($functions, options) {
             if (options.onGeneralError?.call(rpc, e) !== true) throw e;
             return;
         }
-        if (msg.t === TYPE_REQUEST) {
+        if ("q" === msg.t) {
             const { m: method, a: args, o: optional } = msg;
             let result, error;
             let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
@@ -3468,7 +3739,7 @@ function createBirpc($functions, options) {
                 }
                 if (!error) try {
                     await post(serialize({
-                        t: TYPE_RESPONSE,
+                        t: "s",
                         i: msg.i,
                         r: result
                     }), ...extra);
@@ -3479,7 +3750,7 @@ function createBirpc($functions, options) {
                 }
                 try {
                     await post(serialize({
-                        t: TYPE_RESPONSE,
+                        t: "s",
                         i: msg.i,
                         e: error
                     }), ...extra);
@@ -3507,16 +3778,20 @@ class ContainerRpcManager {
     rpc = null;
     methods;
     onDisconnect;
+    onAttach;
     detachActiveSocketListeners = null;
-    constructor(wss, methods, onDisconnect){
+    transportEpoch = 0;
+    constructor(wss, methods, onDisconnect, onAttach){
         this.wss = wss;
         this.methods = methods;
         this.onDisconnect = onDisconnect;
+        this.onAttach = onAttach;
         this.setupConnectionHandler();
     }
-    updateMethods(methods, onDisconnect) {
+    updateMethods(methods, onDisconnect, onAttach) {
         this.methods = methods;
         this.onDisconnect = onDisconnect;
+        this.onAttach = onAttach;
         if (this.ws && this.ws.readyState === this.ws.OPEN) this.attachWebSocket(this.ws);
     }
     setupConnectionHandler() {
@@ -3529,6 +3804,8 @@ class ContainerRpcManager {
     attachWebSocket(ws) {
         this.detachActiveSocketListeners?.();
         if (this.rpc && !this.rpc.$closed) this.rpc.$close(new Error('Container RPC transport reattached'));
+        this.transportEpoch += 1;
+        this.onAttach?.(this.transportEpoch);
         this.ws = ws;
         const messageHandlers = new WeakMap();
         this.rpc = createBirpc(this.methods, {
@@ -3578,30 +3855,19 @@ class ContainerRpcManager {
     reattach(ws) {
         this.attachWebSocket(ws);
     }
-    async notifyTestFileUpdate(files) {
-        await this.rpc?.onTestFileUpdate(files);
+    async notifyTestFileUpdate(files, version) {
+        await this.rpc?.onTestFileUpdate(files, version);
     }
     async updateHostConfig(config) {
         await this.rpc?.onHostConfigUpdate(config);
     }
-    async reloadTestFile(testFile, testNamePattern) {
+    async reloadTestFile(testFile, runId, 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');
-        logger.debug(`[Browser UI] Calling reloadTestFile: ${testFile}`);
-        return this.rpc.reloadTestFile(testFile, testNamePattern);
+        logger.debug(`[Browser UI] Calling reloadTestFile: ${testFile} (run ${runId})`);
+        await this.rpc.reloadTestFile(testFile, runId, testNamePattern);
     }
 }
-const createHeadedSerialTaskQueue = ()=>{
-    let queue = Promise.resolve();
-    const enqueue = (task)=>{
-        const next = queue.then(task);
-        queue = next.catch(()=>{});
-        return next;
-    };
-    return {
-        enqueue
-    };
-};
 const getFileTaskId = (testPath)=>`file:${testPath}`;
 const toError = (error)=>error instanceof Error ? error : new Error(String(error));
 const createDeferredPromise = ()=>{
@@ -3617,6 +3883,105 @@ const createDeferredPromise = ()=>{
         reject
     };
 };
+const RUN_BOOT_DEADLINE_MS = 45000;
+const createHeadedRunRegistry = ()=>{
+    const runsById = new Map();
+    let transportEpoch = 0;
+    const settle = (record, error)=>{
+        if (!runsById.delete(record.runId)) return;
+        clearTimeout(record.bootTimer);
+        clearTimeout(record.cleanupTimer);
+        if (error) record.deferred.reject(error);
+        else record.deferred.resolve();
+    };
+    const sweepOpen = (match, error)=>{
+        for (const record of runsById.values())if ('open' === record.phase && match(record)) settle(record, error);
+    };
+    return {
+        mint (testPath) {
+            sweepOpen((record)=>record.testPath === testPath);
+            const runId = randomUUID();
+            const bootTimer = setTimeout(()=>{
+                const record = runsById.get(runId);
+                if (record) settle(record, new Error(`Headed run for ${testPath} produced no message within ${RUN_BOOT_DEADLINE_MS / 1000}s; its document never booted`));
+            }, RUN_BOOT_DEADLINE_MS);
+            bootTimer.unref?.();
+            const record = {
+                runId,
+                testPath,
+                epoch: transportEpoch,
+                phase: 'open',
+                deferred: createDeferredPromise(),
+                bootTimer
+            };
+            runsById.set(runId, record);
+            return {
+                runId,
+                settled: record.deferred.promise
+            };
+        },
+        admit (runId, terminal) {
+            const record = runsById.get(runId);
+            if (!record) return false;
+            clearTimeout(record.bootTimer);
+            if (!terminal) return true;
+            if ('open' !== record.phase) return false;
+            record.phase = 'claimed';
+            return true;
+        },
+        armCleanupDeadline (runId, ms, onExpire) {
+            const record = runsById.get(runId);
+            if (!record || 'open' !== record.phase) return;
+            clearTimeout(record.cleanupTimer);
+            const cleanupTimer = setTimeout(()=>{
+                const current = runsById.get(runId);
+                if (!current || 'open' !== current.phase) return;
+                current.cleanupTimer = void 0;
+                current.phase = 'claimed';
+                onExpire();
+            }, ms);
+            cleanupTimer.unref?.();
+            record.cleanupTimer = cleanupTimer;
+        },
+        disarmCleanupDeadline (runId) {
+            const record = runsById.get(runId);
+            if (record) {
+                clearTimeout(record.cleanupTimer);
+                record.cleanupTimer = void 0;
+            }
+        },
+        resolve (runId) {
+            const record = runsById.get(runId);
+            if (record) settle(record);
+        },
+        reject (runId, error) {
+            const record = runsById.get(runId);
+            if (record) settle(record, toError(error));
+        },
+        retainPaths (paths) {
+            const retained = new Set(paths);
+            sweepOpen((record)=>!retained.has(record.testPath));
+        },
+        rejectAll (error) {
+            sweepOpen(()=>true, error);
+        },
+        setTransportEpoch (epoch) {
+            transportEpoch = epoch;
+            sweepOpen((record)=>record.epoch < epoch, new Error('Container transport was replaced before the run completed'));
+        }
+    };
+};
+const createHeadedSerialTaskQueue = ()=>{
+    let queue = Promise.resolve();
+    const enqueue = (task)=>{
+        const next = queue.then(task);
+        queue = next.catch(()=>{});
+        return next;
+    };
+    return {
+        enqueue
+    };
+};
 const claimHeadedCycleScope = (testPaths, currentTestFiles, pendingTestNamePatterns)=>{
     const scope = [];
     const filesByPath = new Map(currentTestFiles.map((file)=>[
@@ -3636,131 +4001,161 @@ const claimHeadedCycleScope = (testPaths, currentTestFiles, pendingTestNamePatte
     }
     return scope;
 };
-const createHeadedScheduler = async ({ context, runtime, allTestFiles, hostOptions, isWatchMode, createDispatchRouter, handlers: { handleTestFileStart, handleTestCaseResult, handleTestFileComplete, handleLog, handleFatal }, fatalErrorRef, watchSignals, setDispatchPageResolver, createWatchSession, collectProjectEntries, logWatchReady, destroyRuntime })=>{
+const createHeadedScheduler = async ({ context, runtime, allTestFiles, hostOptions, v8Coverage, projectRoots, isWatchMode, createDispatchRouter, handlers: { handleTestFileComplete }, fatalErrorRef, watchSignals, setDispatchPageResolver, createWatchSession, collectProjectEntries, logWatchReady, destroyRuntime })=>{
     const { browser, browserLaunchOptions, watchState, wss } = runtime;
+    const containerUrl = `http://localhost:${runtime.containerServer.port}/`;
     let currentTestFiles = allTestFiles;
     const RUNNER_FRAMES_READY_TIMEOUT_MS = 30000;
-    let currentRunnerFramesSignature = null;
-    const runnerFramesWaiters = new Map();
-    const createTestFilesSignature = (testFiles)=>JSON.stringify(testFiles.map((testFile)=>normalize(testFile)));
-    const markRunnerFramesReady = (testFiles)=>{
-        const signature = createTestFilesSignature(testFiles);
-        currentRunnerFramesSignature = signature;
-        const waiters = runnerFramesWaiters.get(signature);
-        if (!waiters) return;
-        runnerFramesWaiters.delete(signature);
-        for (const waiter of waiters)waiter();
+    let ackedFrameSetVersion = 0;
+    const frameSetWaiters = new Set();
+    const markFrameSetReady = (version)=>{
+        if (version > watchState.headedFileSetVersion) return;
+        if (version > ackedFrameSetVersion) ackedFrameSetVersion = version;
+        for (const waiter of frameSetWaiters)if (waiter.version <= ackedFrameSetVersion) {
+            clearTimeout(waiter.timeoutId);
+            frameSetWaiters.delete(waiter);
+            waiter.resolve();
+        }
     };
-    const waitForRunnerFramesReady = async (testFiles)=>{
-        const signature = createTestFilesSignature(testFiles);
-        if (currentRunnerFramesSignature === signature) return;
+    const waitForFrameSet = async (version)=>{
+        if (ackedFrameSetVersion >= version) return;
         await new Promise((resolve, reject)=>{
-            const waiters = runnerFramesWaiters.get(signature) ?? new Set();
-            const cleanup = ()=>{
-                const currentWaiters = runnerFramesWaiters.get(signature);
-                if (!currentWaiters) return;
-                currentWaiters.delete(onReady);
-                if (0 === currentWaiters.size) runnerFramesWaiters.delete(signature);
-            };
-            const onReady = ()=>{
-                if (timeoutId) clearTimeout(timeoutId);
-                cleanup();
-                resolve();
+            const waiter = {
+                version,
+                resolve,
+                timeoutId: setTimeout(()=>{
+                    frameSetWaiters.delete(waiter);
+                    reject(new Error(`Timed out waiting for headed runner frames to be ready (file-set version ${version}).`));
+                }, RUNNER_FRAMES_READY_TIMEOUT_MS)
             };
-            const timeoutId = setTimeout(()=>{
-                cleanup();
-                reject(new Error(`Timed out waiting for headed runner frames to be ready for ${testFiles.length} file(s).`));
-            }, RUNNER_FRAMES_READY_TIMEOUT_MS);
-            waiters.add(onReady);
-            runnerFramesWaiters.set(signature, waiters);
-            if (currentRunnerFramesSignature === signature) onReady();
+            frameSetWaiters.add(waiter);
         });
     };
-    const getTestFileInfo = (testFile)=>{
+    const findTestFileInfo = (testFile)=>{
         const normalizedTestFile = normalize(testFile);
-        const fileInfo = currentTestFiles.find((file)=>file.testPath === normalizedTestFile);
+        return currentTestFiles.find((file)=>file.testPath === normalizedTestFile);
+    };
+    const getTestFileInfo = (testFile)=>{
+        const fileInfo = findTestFileInfo(testFile);
         if (!fileInfo) throw new Error(`Unknown browser test file: ${JSON.stringify(testFile)}`);
         return fileInfo;
     };
     let containerContext;
     let containerPage;
     let isNewPage = false;
+    const attachContainerPageHandlers = (activeContext, activePage)=>{
+        activePage.on('popup', async (popup)=>{
+            await popup.close().catch(()=>{});
+        });
+        activeContext.on('page', async (page)=>{
+            if (page !== activePage) await page.close().catch(()=>{});
+        });
+        activePage.on('console', (msg)=>{
+            const text = msg.text();
+            if (text.startsWith('[Container]') || text.startsWith('[Runner]')) return void logger.log(color.gray(`[Browser Console] ${text}`));
+            logger.debug(`[Browser Console] ${text}`);
+        });
+    };
+    const createContainerPage = async ()=>{
+        const nextContext = await browser.newContext({
+            providerOptions: browserLaunchOptions.providerOptions,
+            viewport: null
+        });
+        const nextPage = await nextContext.newPage();
+        attachContainerPageHandlers(nextContext, nextPage);
+        return {
+            context: nextContext,
+            page: nextPage
+        };
+    };
     if (isWatchMode && runtime.containerPage && runtime.containerContext) {
         containerContext = runtime.containerContext;
         containerPage = runtime.containerPage;
         logger.log(color.gray('\n[Watch] Reusing existing container page\n'));
     } else {
         isNewPage = true;
-        containerContext = await browser.newContext({
-            providerOptions: browserLaunchOptions.providerOptions,
-            viewport: null
-        });
-        containerPage = await containerContext.newPage();
-        containerPage.on('popup', async (popup)=>{
-            await popup.close().catch(()=>{});
-        });
-        containerContext.on('page', async (page)=>{
-            if (page !== containerPage) await page.close().catch(()=>{});
-        });
+        const created = await createContainerPage();
+        containerContext = created.context;
+        containerPage = created.page;
         if (isWatchMode) {
             runtime.containerPage = containerPage;
             runtime.containerContext = containerContext;
         }
-        containerPage.on('console', (msg)=>{
-            const text = msg.text();
-            if (text.startsWith('[Container]') || text.startsWith('[Runner]')) logger.log(color.gray(`[Browser Console] ${text}`));
-        });
     }
     setDispatchPageResolver(()=>({
             containerPage
         }));
     const dispatchRouter = createDispatchRouter();
     const headedReloadQueue = createHeadedSerialTaskQueue();
-    const pendingHeadedReloads = new Map();
-    let enqueueHeadedReload = async (_file, _testNamePattern)=>{
-        throw new Error('Headed reload queue is not initialized');
+    let rawCoverage = [];
+    let coverageProject;
+    let coverageStarted = false;
+    const startCoverage = async (projectName)=>{
+        if (!v8Coverage) return;
+        await v8Coverage.start(containerPage);
+        coverageStarted = true;
+        coverageProject = projectName;
     };
-    const rejectPendingHeadedReload = (testPath, error, runId)=>{
-        const pending = pendingHeadedReloads.get(testPath);
-        if (!pending) return;
-        if (runId && pending.runId !== runId) return;
-        pendingHeadedReloads.delete(testPath);
-        pending.deferred.reject(error);
+    const collectCoverage = async ()=>{
+        if (!coverageStarted || !v8Coverage) return;
+        coverageStarted = false;
+        const coverage = await v8Coverage.take(containerPage, projectRoots.get(coverageProject ?? '') ?? context.rootPath, coverageProject);
+        if (coverage) rawCoverage.push(coverage);
     };
-    const rejectAllPendingHeadedReloads = (error)=>{
-        for (const [testPath, pending] of pendingHeadedReloads){
-            pendingHeadedReloads.delete(testPath);
-            pending.deferred.reject(error);
-        }
+    let enqueueHeadedReload = async (_file, _testNamePattern)=>{
+        throw new Error('Headed reload queue is not initialized');
     };
-    const registerPendingHeadedReload = (testPath, runId)=>{
-        const previousPending = pendingHeadedReloads.get(testPath);
-        if (previousPending) {
-            previousPending.deferred.reject(new Error(`Reload for "${testPath}" was superseded by a newer request.`));
-            pendingHeadedReloads.delete(testPath);
+    const isCurrentTestFile = (testPath)=>void 0 !== findTestFileInfo(testPath);
+    const runs = watchState.headedRuns ??= createHeadedRunRegistry();
+    const recoverHeadedContainer = async ()=>{
+        ackedFrameSetVersion = 0;
+        await containerContext.close().catch(()=>{});
+        const created = await createContainerPage();
+        containerContext = created.context;
+        containerPage = created.page;
+        if (isWatchMode) {
+            runtime.containerPage = containerPage;
+            runtime.containerContext = containerContext;
         }
-        const deferred = createDeferredPromise();
-        pendingHeadedReloads.set(testPath, {
-            runId,
-            deferred
+        await containerPage.goto(containerUrl, {
+            waitUntil: 'load'
         });
-        return deferred.promise;
-    };
-    const resolvePendingHeadedReload = (testPath, runId)=>{
-        const pending = pendingHeadedReloads.get(testPath);
-        if (!pending) return;
-        if (runId && pending.runId !== runId) return void logger.debug(`[Browser UI] Ignoring stale file-complete for ${testPath}. current=${pending.runId}, incoming=${runId}`);
-        pendingHeadedReloads.delete(testPath);
-        pending.deferred.resolve();
+        await waitForFrameSet(watchState.headedFileSetVersion);
     };
+    dispatchRouter.register(DISPATCH_NAMESPACE_FILE_CLEANUP, async (request)=>{
+        const { runId } = request;
+        if (!runId) return;
+        if ('start' === request.method) {
+            const payload = request.args;
+            runs.armCleanupDeadline(runId, FIXTURE_CLEANUP_TIMEOUT_MS, ()=>{
+                (async ()=>{
+                    try {
+                        await collectCoverage();
+                        await handleTestFileComplete(createFileCleanupTimeoutResult({
+                            message: `File fixture cleanup did not finish within ${FIXTURE_CLEANUP_TIMEOUT_MS}ms`,
+                            projectName: payload.projectName,
+                            result: payload.result,
+                            testPath: payload.testPath
+                        }));
+                        await recoverHeadedContainer();
+                        runs.resolve(runId);
+                    } catch (error) {
+                        runs.reject(runId, toError(error));
+                    }
+                })();
+            });
+        } else if ('end' === request.method) runs.disarmCleanupDeadline(runId);
+    });
     const reloadTestFileAndWait = async (file, testNamePattern)=>{
-        let reloadAck;
+        await startCoverage(file.projectName);
+        const { runId, settled } = runs.mint(file.testPath);
+        rpcManager.reloadTestFile(file.testPath, runId, testNamePattern).catch((error)=>runs.reject(runId, error));
         try {
-            reloadAck = await rpcManager.reloadTestFile(file.testPath, testNamePattern);
-            await registerPendingHeadedReload(file.testPath, reloadAck.runId);
-        } catch (error) {
-            if (reloadAck?.runId) rejectPendingHeadedReload(file.testPath, toError(error), reloadAck.runId);
-            throw error;
+            await settled;
+        } finally{
+            await collectCoverage().catch((error)=>{
+                logger.debug(`[Headed] Failed to flush coverage: ${error}`);
+            });
         }
     };
     let runUiRequestedRerun = async (file, testNamePattern)=>{
@@ -3775,66 +4170,73 @@ const createHeadedScheduler = async ({ context, runtime, allTestFiles, hostOptio
                 await runUiRequestedRerun(getTestFileInfo(testFile), testNamePattern);
             },
             async getTestFiles () {
-                return currentTestFiles;
-            },
-            async onRunnerFramesReady (testFiles) {
-                markRunnerFramesReady(testFiles);
-            },
-            async onTestFileStart (payload) {
-                await handleTestFileStart(payload);
+                return {
+                    files: currentTestFiles,
+                    version: watchState.headedFileSetVersion
+                };
             },
-            async onTestCaseResult (payload) {
-                await handleTestCaseResult(payload);
+            async onFrameSetReady (version) {
+                markFrameSetReady(version);
             },
-            async onTestFileComplete (payload) {
-                try {
-                    await handleTestFileComplete(payload);
-                    resolvePendingHeadedReload(payload.testPath, payload.runId);
+            async dispatch (request) {
+                const { method, runId } = request;
+                const isTerminal = "runner" === request.namespace && ('file-complete' === method || 'fatal' === method);
+                if (!runId || !runs.admit(runId, isTerminal)) {
+                    logger.debug(`[Headed] Dropped stale "${method}" from run ${runId ?? '(none)'}`);
+                    return {
+                        requestId: request.requestId,
+                        stale: true
+                    };
+                }
+                let coverageError;
+                if (isTerminal) try {
+                    await collectCoverage();
                 } catch (error) {
-                    rejectPendingHeadedReload(payload.testPath, toError(error), payload.runId);
-                    throw error;
+                    coverageError = toError(error);
                 }
-            },
-            async onLog (payload) {
-                await handleLog(payload);
-            },
-            async onFatal (payload) {
-                const error = new Error(payload.message);
-                error.stack = payload.stack;
-                rejectAllPendingHeadedReloads(error);
-                await handleFatal(payload);
-            },
-            async dispatch (request) {
-                return dispatchRouter.dispatch(request);
+                const response = await dispatchRouter.dispatch(request);
+                if (!isTerminal) return response;
+                if ('file-complete' === method) {
+                    const failure = coverageError ?? (response.error ? new Error(response.error) : void 0);
+                    if (failure) runs.reject(runId, failure);
+                    else runs.resolve(runId);
+                } else {
+                    if (coverageError) logger.error(`[Headed] Failed to take coverage during fatal handling: ${coverageError.message}`);
+                    const payload = request.args;
+                    const error = new Error(payload?.message ?? 'Fatal browser error');
+                    if (payload?.stack) error.stack = payload.stack;
+                    runs.reject(runId, error);
+                }
+                return response;
             }
         });
     let rpcManager;
     if (isWatchMode && runtime.rpcManager) {
         rpcManager = runtime.rpcManager;
-        rpcManager.updateMethods(createRpcMethods(), rejectAllPendingHeadedReloads);
+        rpcManager.updateMethods(createRpcMethods(), runs.rejectAll, runs.setTransportEpoch);
         const existingWs = rpcManager.currentWebSocket;
         if (existingWs) rpcManager.reattach(existingWs);
     } else {
-        rpcManager = new ContainerRpcManager(wss, createRpcMethods(), rejectAllPendingHeadedReloads);
+        rpcManager = new ContainerRpcManager(wss, createRpcMethods(), runs.rejectAll, runs.setTransportEpoch);
         if (isWatchMode) runtime.rpcManager = rpcManager;
     }
     if (isNewPage) {
-        const pagePath = '/';
-        const containerPort = runtime.containerServer.port;
-        await containerPage.goto(`http://localhost:${containerPort}${pagePath}`, {
+        await containerPage.goto(containerUrl, {
             waitUntil: 'load'
         });
-        logger.log(color.cyan(`\nBrowser mode opened at http://localhost:${containerPort}${pagePath}\n`));
+        logger.log(color.cyan(`\nBrowser mode opened at ${containerUrl}\n`));
     }
     enqueueHeadedReload = async (file, testNamePattern)=>headedReloadQueue.enqueue(async ()=>{
             if (fatalErrorRef.current) return;
+            if (!isCurrentTestFile(file.testPath)) return void logger.debug(`[Browser UI] Skipping reload for removed test file: ${file.testPath}`);
             await reloadTestFileAndWait(file, testNamePattern);
         });
     let testTime = 0;
     if (currentTestFiles.length > 0) {
         const testStart = Date.now();
         try {
-            await waitForRunnerFramesReady(currentTestFiles.map((file)=>file.testPath));
+            if (rpcManager.isConnected) await rpcManager.notifyTestFileUpdate(currentTestFiles, watchState.headedFileSetVersion);
+            await waitForFrameSet(watchState.headedFileSetVersion);
             for (const file of currentTestFiles){
                 await enqueueHeadedReload(file);
                 if (fatalErrorRef.current) break;
@@ -3848,8 +4250,10 @@ const createHeadedScheduler = async ({ context, runtime, allTestFiles, hostOptio
     if (isWatchMode) {
         const pendingTestNamePatterns = new Map();
         const runScope = async (testPaths)=>{
+            rawCoverage = [];
             const cycleScope = claimHeadedCycleScope(testPaths, currentTestFiles, pendingTestNamePatterns);
             for (const { file, testNamePattern } of cycleScope)await enqueueHeadedReload(file, testNamePattern);
+            return rawCoverage;
         };
         const refreshHostConfig = async ()=>{
             const refreshedHostOptions = {
@@ -3861,46 +4265,44 @@ const createHeadedScheduler = async ({ context, runtime, allTestFiles, hostOptio
             runtime.setContainerOptions(refreshedHostOptions);
             await rpcManager.updateHostConfig(refreshedHostOptions);
         };
-        watchSignals.setDispatchRerun(async ()=>{
-            const [, newProjectEntries] = await Promise.all([
-                refreshHostConfig(),
-                collectProjectEntries()
-            ]);
-            const rerunPlan = planWatchRerun({
-                projectEntries: newProjectEntries,
-                previousTestFiles: watchState.lastTestFiles,
-                affectedTestFiles: drainPendingAffectedTestFiles(watchState)
-            });
-            if (rerunPlan.filesChanged) {
-                const deletedTestPaths = collectDeletedTestPaths(watchState.lastTestFiles, rerunPlan.currentTestFiles);
-                if (deletedTestPaths.length > 0) context.updateReporterResultState([], [], deletedTestPaths);
-                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'));
-                    logWatchReady();
-                    return;
+        const runDispatchRerunOnce = async ()=>{
+            try {
+                const [, newProjectEntries] = await Promise.all([
+                    refreshHostConfig(),
+                    collectProjectEntries()
+                ]);
+                const rerunPlan = planWatchRerun({
+                    projectEntries: newProjectEntries,
+                    previousTestFiles: watchState.lastTestFiles,
+                    affectedTestFiles: drainPendingAffectedTestFiles(watchState)
+                });
+                commitWatchFileSetUpdate(rerunPlan.fileSetUpdate, watchState, (deletedTestPaths)=>context.updateReporterResultState([], [], deletedTestPaths));
+                if (rerunPlan.fileSetUpdate) {
+                    currentTestFiles = rerunPlan.fileSetUpdate.currentTestFiles;
+                    const version = watchState.headedFileSetVersion += 1;
+                    runs.retainPaths(currentTestFiles.map((file)=>file.testPath));
+                    await rpcManager.notifyTestFileUpdate(currentTestFiles, version);
+                    if (currentTestFiles.length > 0) await waitForFrameSet(version);
                 }
-                await waitForRunnerFramesReady(currentTestFiles.map((file)=>file.testPath));
-            }
-            if (rerunPlan.normalizedAffectedTestFiles.length > 0) {
-                logger.log(color.cyan(`Re-running ${rerunPlan.normalizedAffectedTestFiles.length} affected test file(s)...\n`));
-                await watchSignals.signalInvalidation(rerunPlan.normalizedAffectedTestFiles);
-                return;
+                logger.log(color.cyan(rerunPlan.decision.message));
+                if ('idle' === rerunPlan.decision.kind) return void logWatchReady();
+                await watchSignals.signalInvalidation('empty' === rerunPlan.decision.kind ? [] : rerunPlan.decision.testPaths);
+            } catch (error) {
+                logWatchReady();
+                throw error;
             }
-            if (!rerunPlan.filesChanged) logger.log(color.cyan('Tests will be re-executed automatically\n'));
-            logWatchReady();
-        });
+        };
+        const dispatchRerunQueue = createHeadedSerialTaskQueue();
+        watchSignals.setDispatchRerun(()=>dispatchRerunQueue.enqueue(runDispatchRerunOnce));
         runUiRequestedRerun = async (file, testNamePattern)=>{
             await refreshHostConfig();
-            await watchSignals.signalInvalidation([
+            const { cycle } = await watchSignals.signalInvalidation([
                 file.testPath
             ], ()=>{
                 if (void 0 === testNamePattern) pendingTestNamePatterns.delete(normalize(file.testPath));
                 else pendingTestNamePatterns.set(normalize(file.testPath), testNamePattern);
             });
-            await watchSignals.awaitSignalledCycle();
+            await cycle;
         };
         watchSession = createWatchSession(runScope);
     }
@@ -3915,6 +4317,7 @@ const createHeadedScheduler = async ({ context, runtime, allTestFiles, hostOptio
     };
     return {
         testTime,
+        rawCoverage,
         watchSession,
         close: closeContainerRuntime
     };
@@ -4053,8 +4456,12 @@ class RunnerSessionRegistry {
         this.sessionIdByTestFile.clear();
     }
 }
-const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions, projectServers, allTestFiles, projectRuntimeConfigs, hostOptions, watchState, isWatchMode, createDispatchRouter, handlers: { handleFatal, handleTestFileComplete }, watchSignals, setDispatchPageResolver, createWatchSession, collectProjectEntries, logWatchReady, destroyRuntime })=>{
+const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions, projectServers, v8Coverage, allTestFiles, projectRuntimeConfigs, hostOptions, watchState, isWatchMode, createDispatchRouter, handlers: { handleFatal, handleTestFileComplete }, watchSignals, setDispatchPageResolver, createWatchSession, collectProjectEntries, logWatchReady, destroyRuntime })=>{
     const viewportByProject = mapViewportByProject(projectRuntimeConfigs);
+    const projectRootByName = new Map(projectRuntimeConfigs.map((project)=>[
+            project.name,
+            project.projectRoot
+        ]));
     const runLifecycle = new RunSessionLifecycle();
     const sessionRegistry = new RunnerSessionRegistry();
     setDispatchPageResolver((target)=>({
@@ -4075,12 +4482,32 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
             }
         });
     };
+    const collectRunCoverage = async (run)=>{
+        const results = await Promise.allSettled(Array.from(run.coverageCollectors, (collect)=>collect()));
+        for (const result of results)if ('rejected' === result.status) {
+            const error = toError(result.reason);
+            await handleFatal({
+                message: error.message,
+                stack: error.stack
+            });
+        }
+    };
     const dispatchRouter = createDispatchRouter({
         isRunTokenStale: (runToken)=>runLifecycle.isTokenStale(runToken),
         onStale: (request)=>{
             if ("runner" === request.namespace) logger.debug(`[Headless] Dropped stale message "${request.method}" for ${request.target?.testFile ?? 'unknown'}`);
         }
     });
+    const fileCleanupHandlers = new Map();
+    dispatchRouter.register(DISPATCH_NAMESPACE_FILE_CLEANUP, async (request)=>{
+        const sessionId = request.target?.sessionId;
+        if (!sessionId) throw new Error('File cleanup dispatch is missing a browser session.');
+        const handler = fileCleanupHandlers.get(sessionId);
+        if (!handler) return;
+        const payload = request.args;
+        if ('start' === request.method) handler.start(payload.result);
+        else if ('end' === request.method) handler.end();
+    });
     const dispatchRunnerMessage = async (run, file, sessionId, message)=>{
         const response = await dispatchRouter.dispatch({
             requestId: nextDispatchRequestId("runner"),
@@ -4097,7 +4524,7 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
         if (response.stale) return;
         if (response.error) throw new Error(response.error);
     };
-    const runSingleFile = async (run, file)=>{
+    const runSingleFile = async (run, file, rawCoverage)=>{
         if (run.cancelled || runLifecycle.isTokenStale(run.token)) return;
         const viewport = viewportByProject.get(file.projectName);
         const browserContext = await browser.newContext({
@@ -4107,8 +4534,12 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
         run.contexts.add(browserContext);
         let page = null;
         let sessionId = null;
+        let coverageCollection;
         let settled = false;
         let resolveDone = null;
+        let cleanupTimer;
+        let fileCleanupFinished = false;
+        let provisionalResult;
         const markDone = ()=>{
             if (!settled) {
                 settled = true;
@@ -4124,8 +4555,18 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
             settled = true;
             crashDeferred.resolve(reason);
         };
+        const collectCoverage = async ()=>{
+            if (!page || !v8Coverage) return;
+            if (!coverageCollection) coverageCollection = (async ()=>{
+                const coverage = await v8Coverage.take(page, projectRootByName.get(file.projectName) ?? context.rootPath, file.projectName);
+                if (coverage) rawCoverage.push(coverage);
+            })();
+            await coverageCollection;
+        };
         try {
             page = await browserContext.newPage();
+            await v8Coverage?.start(page);
+            run.coverageCollectors.add(collectCoverage);
             page.on('crash', ()=>onPageDead(`Browser page crashed while running ${file.testPath}.`));
             page.on('close', ()=>onPageDead(`Browser page closed unexpectedly while running ${file.testPath}.`));
             const session = sessionRegistry.register({
@@ -4137,13 +4578,61 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
                 page
             });
             sessionId = session.id;
+            const clearFileCleanupTimeout = ()=>{
+                if (cleanupTimer) {
+                    clearTimeout(cleanupTimer);
+                    cleanupTimer = void 0;
+                }
+            };
+            const finishFileCleanup = ()=>{
+                fileCleanupFinished = true;
+                clearFileCleanupTimeout();
+            };
+            fileCleanupHandlers.set(session.id, {
+                end: finishFileCleanup,
+                start: (result)=>{
+                    if (fileCleanupFinished) return;
+                    provisionalResult = result;
+                    clearFileCleanupTimeout();
+                    cleanupTimer = setTimeout(()=>{
+                        (async ()=>{
+                            if (settled) return;
+                            settled = true;
+                            const message = `File fixture cleanup did not finish within ${FIXTURE_CLEANUP_TIMEOUT_MS}ms`;
+                            try {
+                                await collectCoverage();
+                                await handleTestFileComplete(createFileCleanupTimeoutResult({
+                                    message,
+                                    projectName: file.projectName,
+                                    result: provisionalResult,
+                                    testPath: file.testPath
+                                }));
+                            } catch (error) {
+                                const formatted = toError(error);
+                                await handleFatal({
+                                    message: formatted.message,
+                                    stack: formatted.stack
+                                });
+                                await collectRunCoverage(run);
+                                await cancelRun(run, false);
+                            } finally{
+                                resolveDone?.();
+                            }
+                        })();
+                    }, FIXTURE_CLEANUP_TIMEOUT_MS);
+                }
+            });
             await attachHeadlessRunnerTransport(page, {
-                onDispatchMessage: async (message)=>{
+                onDispatchMessage: async (envelope)=>{
+                    const message = envelope.message;
                     try {
+                        if (settled) return;
+                        if ('file-complete' === message.type || 'fatal' === message.type) await collectCoverage();
                         await dispatchRunnerMessage(run, file, session.id, message);
-                        if ('file-complete' === message.type || 'complete' === message.type) markDone();
+                        if ('file-complete' === message.type) markDone();
                         else if ('fatal' === message.type) {
                             markDone();
+                            await collectRunCoverage(run);
                             await cancelRun(run, false);
                         }
                     } catch (error) {
@@ -4153,6 +4642,7 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
                             stack: formatted.stack
                         });
                         markDone();
+                        await collectRunCoverage(run);
                         await cancelRun(run, false);
                     }
                 },
@@ -4196,6 +4686,7 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
             ]);
             if ('cancelled' === state.type) return;
             if ('crash' === state.type && runLifecycle.isTokenActive(run.token) && !run.cancelled) {
+                await collectRunCoverage(run);
                 await handleFatal({
                     message: state.reason
                 });
@@ -4203,6 +4694,7 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
             }
         } catch (error) {
             if (runLifecycle.isTokenActive(run.token) && !run.cancelled) {
+                await collectRunCoverage(run);
                 const formatted = toError(error);
                 await handleFatal({
                     message: formatted.message,
@@ -4211,6 +4703,9 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
                 await cancelRun(run, false);
             }
         } finally{
+            if (cleanupTimer) clearTimeout(cleanupTimer);
+            if (sessionId) fileCleanupHandlers.delete(sessionId);
+            run.coverageCollectors.delete(collectCoverage);
             const abandoned = run.cancelled || runLifecycle.isTokenStale(run.token);
             const teardown = async ()=>{
                 if (page) try {
@@ -4233,12 +4728,14 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
             results: []
         });
     const runFilesWithPool = async (files)=>{
-        if (0 === files.length) return;
+        const rawCoverage = [];
+        if (0 === files.length) return rawCoverage;
         const previous = runLifecycle.activeSession;
         if (previous) await cancelRun(previous);
         const run = runLifecycle.createSession((token)=>({
                 ...createRunSession(token),
-                contexts: new Set()
+                contexts: new Set(),
+                coverageCollectors: new Set()
             }));
         const queue = [
             ...files
@@ -4257,7 +4754,7 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
                 }
                 const next = queue.shift();
                 if (!next) return;
-                await runSingleFile(run, next);
+                await runSingleFile(run, next, rawCoverage);
             }
         };
         run.done = Promise.all(Array.from({
@@ -4265,15 +4762,16 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
         }, ()=>worker())).then(()=>{});
         await run.done;
         runLifecycle.clearIfActive(run);
+        return rawCoverage;
     };
     const testStart = Date.now();
-    await runFilesWithPool(allTestFiles);
+    const rawCoverage = await runFilesWithPool(allTestFiles);
     const testTime = Date.now() - testStart;
     let watchSession;
     if (isWatchMode) {
         const runScope = async (testPaths)=>{
             const pathSet = new Set(testPaths.map((testPath)=>normalize(testPath)));
-            await runFilesWithPool(watchState.lastTestFiles.filter((file)=>pathSet.has(file.testPath)));
+            return runFilesWithPool(watchState.lastTestFiles.filter((file)=>pathSet.has(file.testPath)));
         };
         watchSignals.setInterrupt(async ()=>{
             const active = runLifecycle.activeSession;
@@ -4290,30 +4788,10 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
                 previousTestFiles: watchState.lastTestFiles,
                 affectedTestFiles: drainPendingAffectedTestFiles(watchState)
             });
-            if (rerunPlan.filesChanged) {
-                const deletedTestPaths = collectDeletedTestPaths(watchState.lastTestFiles, rerunPlan.currentTestFiles);
-                if (deletedTestPaths.length > 0) context.updateReporterResultState([], [], deletedTestPaths);
-                watchState.lastTestFiles = rerunPlan.currentTestFiles;
-                if (0 === rerunPlan.currentTestFiles.length) {
-                    logger.log(color.cyan('No browser test files remain after update.\n'));
-                    await watchSignals.signalInvalidation([]);
-                    return;
-                }
-                logger.log(color.cyan(`Test file set changed, re-running ${rerunPlan.currentTestFiles.length} file(s)...\n`));
-                await watchSignals.signalInvalidation([
-                    ...new Set(rerunPlan.currentTestFiles.map((file)=>file.testPath))
-                ]);
-                return;
-            }
-            if (0 === rerunPlan.affectedTestFiles.length) {
-                logger.log(color.cyan('No affected browser test files detected, skipping re-run.\n'));
-                logWatchReady();
-                return;
-            }
-            logger.log(color.cyan(`Re-running ${rerunPlan.affectedTestFiles.length} affected test file(s)...\n`));
-            await watchSignals.signalInvalidation([
-                ...new Set(rerunPlan.affectedTestFiles.map((file)=>file.testPath))
-            ]);
+            commitWatchFileSetUpdate(rerunPlan.fileSetUpdate, watchState, (deletedTestPaths)=>context.updateReporterResultState([], [], deletedTestPaths));
+            logger.log(color.cyan(rerunPlan.decision.message));
+            if ('idle' === rerunPlan.decision.kind) return void logWatchReady();
+            await watchSignals.signalInvalidation('empty' === rerunPlan.decision.kind ? [] : rerunPlan.decision.testPaths);
         });
         watchSession = createWatchSession(runScope);
     }
@@ -4323,6 +4801,7 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
     };
     return {
         testTime,
+        rawCoverage,
         watchSession,
         close: closeHeadlessRuntime
     };
@@ -4351,7 +4830,6 @@ const validateBrowserRpcRequest = (payload)=>{
     const request = {
         id: readString(payload, 'id', 'id'),
         testPath: readString(payload, 'testPath', 'testPath'),
-        runId: readString(payload, 'runId', 'runId'),
         kind,
         locator: parseBrowserLocatorIR(payload.locator, 'locator'),
         method: readString(payload, 'method', 'method'),
@@ -4369,47 +4847,6 @@ const validateBrowserRpcRequest = (payload)=>{
     }
     return request;
 };
-const normalizeJavaScriptUrl = (value, options)=>{
-    try {
-        const url = options?.origin ? new URL(value, options.origin) : new URL(value);
-        if ('http:' !== url.protocol && 'https:' !== url.protocol) return null;
-        url.search = '';
-        url.hash = '';
-        return url.toString();
-    } catch  {
-        return null;
-    }
-};
-const resolveInlineSourceMap = (code)=>{
-    const converter = convert_source_map.fromSource(code);
-    if (!converter) return null;
-    return converter.toObject();
-};
-const fetchSourceMap = async (jsUrl, fetcher)=>{
-    const jsResponse = await fetcher(jsUrl);
-    if (!jsResponse.ok) return null;
-    const code = await jsResponse.text();
-    const inlineMap = resolveInlineSourceMap(code);
-    if (inlineMap) return inlineMap;
-    const mapResponse = await fetcher(`${jsUrl}.map`);
-    if (!mapResponse.ok) return null;
-    return await mapResponse.json();
-};
-const loadSourceMapWithCache = async ({ jsUrl, cache, force = false, origin, fetcher = fetch })=>{
-    const normalizedUrl = normalizeJavaScriptUrl(jsUrl, {
-        origin
-    });
-    if (!normalizedUrl) return null;
-    if (!force && cache.has(normalizedUrl)) return cache.get(normalizedUrl) ?? null;
-    try {
-        const sourceMap = await fetchSourceMap(normalizedUrl, fetcher);
-        cache.set(normalizedUrl, sourceMap);
-        return sourceMap;
-    } catch  {
-        cache.set(normalizedUrl, null);
-        return null;
-    }
-};
 const watchContext = {
     runtime: null,
     cleanupRegistered: false,
@@ -4455,12 +4892,16 @@ const createWatchSignals = (onInvalidate)=>{
         async signalInvalidation (fileFilters, claimScope) {
             await interruptInFlightRun?.();
             claimScope?.();
-            signalledCycle = Promise.resolve(onInvalidate?.({
+            const cycle = Promise.resolve(onInvalidate?.({
                 isFirstBuild: false,
                 fileFilters
-            })).catch((error)=>{
+            })).then(()=>{}, (error)=>{
                 logger.error(color.red('Browser Mode watch cycle failed:'), error);
             });
+            signalledCycle = cycle;
+            return {
+                cycle
+            };
         },
         async awaitSignalledCycle () {
             await signalledCycle;
@@ -4490,6 +4931,21 @@ const runBrowserController = async (context, options)=>{
     const browserProjects = options?.projects ?? getBrowserProjects(context);
     const useHeadlessDirect = browserProjects.every((project)=>project.normalizedConfig.browser.headless);
     const browserSourceMapCache = new Map();
+    const browserCoverageResources = {
+        assetFiles: new Map(),
+        sourceMaps: new Map()
+    };
+    const loadBrowserCoverageResources = async (filenames, resource)=>{
+        const store = browserCoverageResources[resource];
+        const loaded = {};
+        for (const filename of filenames){
+            const value = store.get(filename);
+            if (void 0 !== value) loaded[filename] = value;
+        }
+        return loaded;
+    };
+    const loadBrowserCoverageAssetFiles = (filenames)=>loadBrowserCoverageResources(filenames, 'assetFiles');
+    const loadBrowserCoverageSourceMaps = (filenames)=>loadBrowserCoverageResources(filenames, 'sourceMaps');
     const isHttpLikeFile = (file)=>/^https?:\/\//.test(file);
     const resolveBrowserSourcemap = async (sourcePath)=>{
         if (!isHttpLikeFile(sourcePath)) return {
@@ -4546,7 +5002,8 @@ 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 coverageProvider = !filesOnly && 'list' !== context.command && coverageConfig?.enabled ? await createCoverageProvider(coverageConfig, context.rootPath) : null;
+    const browserCoverageCapabilityError = filesOnly || 'list' === context.command || coverageConfig?.provider !== 'v8' || (browserProjects[0]?.normalizedConfig.browser.browser ?? 'chromium') !== 'chromium' || coverageProvider?.supportsBrowserCoverage === true ? void 0 : new Error("The installed @rstest/coverage-v8 provider does not support Chromium Browser Mode coverage. Upgrade @rstest/coverage-v8 to the version matching @rstest/core, or use coverage.provider: 'istanbul'.");
     const containerDevServerEnv = process.env.RSTEST_CONTAINER_DEV_SERVER;
     let containerDevServer;
     let containerDistPath;
@@ -4609,12 +5066,9 @@ const runBrowserController = async (context, options)=>{
                 freezeShardedEntries: options?.freezeShardedEntries,
                 tempDir,
                 isWatchMode,
-                onTriggerRerun: isWatchMode ? async ()=>{
-                    await watchSignals.runDispatchRerun();
-                } : void 0,
                 containerDistPath,
                 containerDevServer,
-                skipProviderLaunch: filesOnly,
+                skipProviderLaunch: filesOnly || Boolean(browserCoverageCapabilityError),
                 appliedModifyRstestConfigEnvironments: options?.appliedModifyRstestConfigEnvironments
             });
         } catch (error) {
@@ -4625,13 +5079,18 @@ const runBrowserController = async (context, options)=>{
                 }).catch(()=>{});
             });
         }
-        if (isWatchMode && !filesOnly) {
+        if (isWatchMode && !filesOnly && !browserCoverageCapabilityError) {
             watchContext.runtime = runtime;
             registerWatchCleanup(context.embedded);
         }
     }
     const watchState = runtime.watchState;
-    if (isWatchMode) watchState.lastTestFiles = collectWatchTestFiles(projectEntries);
+    if (isWatchMode) {
+        watchState.lastTestFiles = collectWatchTestFiles(projectEntries);
+        watchState.triggerRerun = async ()=>{
+            await watchSignals.runDispatchRerun();
+        };
+    }
     const seedPendingRerun = (testPaths)=>{
         const wanted = testPaths ? new Set(testPaths.map((testPath)=>normalize(testPath))) : null;
         let seeded = 0;
@@ -4644,7 +5103,7 @@ const runBrowserController = async (context, options)=>{
         }
         return seeded;
     };
-    const buildRerunOutcome = ({ rerunTestPaths, testTime, unhandledErrors })=>{
+    const buildRerunOutcome = ({ rerunTestPaths, testTime, rawCoverage, unhandledErrors })=>{
         const rerunPathSet = new Set(rerunTestPaths);
         const rerunResults = context.reporterResults.results.filter((result)=>rerunPathSet.has(result.testPath));
         const coverageMap = buildBrowserCoverageMap(rerunResults, coverageProvider);
@@ -4657,8 +5116,11 @@ const runBrowserController = async (context, options)=>{
                 buildTime: drainPendingBuildTime(watchState),
                 testTime
             },
-            coverage: coverageMap?.files().length ? {
-                map: coverageMap.toJSON()
+            coverage: coverageMap?.files().length || rawCoverage.length ? {
+                map: coverageMap?.toJSON(),
+                raw: rawCoverage,
+                loadAssetFiles: loadBrowserCoverageAssetFiles,
+                loadSourceMaps: loadBrowserCoverageSourceMaps
             } : void 0,
             resolveSourcemap: resolveBrowserSourcemap
         };
@@ -4666,17 +5128,19 @@ const runBrowserController = async (context, options)=>{
     const createWatchSession = (execute)=>({
             runCycle: async (testPaths)=>{
                 const rerunStartTime = Date.now();
-                const fatalErrorBeforeRun = fatalErrorRef.current;
+                fatalErrorRef.current = null;
                 let rerunError;
+                let rawCoverage = [];
                 try {
-                    await execute(testPaths);
+                    rawCoverage = await execute(testPaths);
                 } catch (error) {
                     rerunError = toError(error);
                 }
-                const rerunFatalError = fatalErrorRef.current && fatalErrorRef.current !== fatalErrorBeforeRun ? fatalErrorRef.current : void 0;
+                const rerunFatalError = fatalErrorRef.current ?? void 0;
                 return buildRerunOutcome({
                     rerunTestPaths: testPaths,
                     testTime: Math.max(0, Date.now() - rerunStartTime),
+                    rawCoverage,
                     unhandledErrors: rerunError ? [
                         rerunError
                     ] : rerunFatalError ? [
@@ -4712,6 +5176,10 @@ const runBrowserController = async (context, options)=>{
         await destroyBrowserRuntime(runtime);
         return allowEmptyRun ? createEmptyRunResult() : void 0;
     }
+    if (browserCoverageCapabilityError) {
+        await destroyBrowserRuntime(runtime);
+        return failWithError(browserCoverageCapabilityError);
+    }
     const { browser, browserLaunchOptions, wsPort } = runtime;
     const allTestFiles = projectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
                 testPath: normalize(testPath),
@@ -4734,17 +5202,18 @@ const runBrowserController = async (context, options)=>{
             name,
             `http://localhost:${server.port}`
         ]));
+    const containerRunnerUrl = `http://localhost:${runtime.containerServer.port}`;
     const hostOptions = {
         rootPath: normalize(context.rootPath),
         projects: projectRuntimeConfigs,
         snapshot: {
             updateSnapshot: options?.updateSnapshot ?? context.snapshotManager.options.updateSnapshot
         },
-        runnerUrl: `http://localhost:${runtime.containerServer.port}`,
+        runnerUrl: containerRunnerUrl,
         projectRunnerUrls,
         wsPort,
         debug: isDebug(),
-        rpcTimeout: maxTestTimeoutForRpc
+        rpcTimeout: -1
     };
     const browserProviderProjects = browserProjects.map((project)=>({
             rootPath: normalize(project.rootPath),
@@ -4752,6 +5221,22 @@ const runBrowserController = async (context, options)=>{
         }));
     const implementationByProvider = new Map();
     for (const browserProject of browserProviderProjects)if (!implementationByProvider.has(browserProject.provider)) implementationByProvider.set(browserProject.provider, getBrowserProviderImplementation(browserProject.provider));
+    const browserName = browserLaunchOptions.browser ?? 'chromium';
+    const v8CoverageCollector = coverageConfig?.provider === 'v8' ? implementationByProvider.get(browserLaunchOptions.provider)?.createV8CoverageCollector?.({
+        browserName
+    }) ?? null : null;
+    const v8Coverage = v8CoverageCollector ? {
+        start: v8CoverageCollector.start,
+        take: (page, projectRoot, projectName)=>takeBrowserV8Coverage({
+                collector: v8CoverageCollector,
+                fetchTimeout: maxTestTimeoutForRpc,
+                page,
+                projectUrl: projectRunnerUrls[projectName ?? ''] ?? containerRunnerUrl,
+                rootPath: normalize(projectRoot),
+                sourceMapCache: browserSourceMapCache,
+                resourceStore: browserCoverageResources
+            })
+    } : void 0;
     let resolveDispatchPages = ()=>({});
     const setDispatchPageResolver = (resolver)=>{
         resolveDispatchPages = resolver;
@@ -4801,14 +5286,22 @@ const runBrowserController = async (context, options)=>{
         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)=>sinkForProjectName(log.project).onConsoleLog(log),
-        writeOriginalLog: ()=>{}
-    });
+    const silentConsoleControllers = new Map(browserProjects.map((project)=>[
+            project.name,
+            createSilentConsoleController({
+                runtimeConfig: {
+                    silent: project.normalizedConfig.silent,
+                    disableConsoleIntercept: project.normalizedConfig.disableConsoleIntercept
+                },
+                emitInterceptedLog: (log)=>sinkForProjectName(log.project).onConsoleLog(log),
+                writeOriginalLog: ()=>{}
+            })
+        ]));
+    const silentConsoleControllerForProjectName = (projectName)=>{
+        const controller = silentConsoleControllers.get(projectName);
+        if (!controller) throw new Error(`No silent console controller for project "${projectName}"`);
+        return controller;
+    };
     const snapshotRpcMethods = {
         async resolveSnapshotPath (testPath) {
             return resolveSnapshotPathDefault(testPath, context.normalizedConfig.resolveSnapshotPath);
@@ -4863,7 +5356,7 @@ const runBrowserController = async (context, options)=>{
     const handleTestSuiteResult = async (payload)=>{
         phaseTrackers?.get(trackerKey(payload.project, payload.testPath))?.recordSuiteResult(payload);
         await sinkForProjectName(payload.project).onTestSuiteResult(payload);
-        if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
+        silentConsoleControllerForProjectName(payload.project).flushBufferedLogsForTask({
             taskId: payload.testId,
             status: payload.status,
             taskParentNames: payload.parentNames,
@@ -4879,7 +5372,7 @@ const runBrowserController = async (context, options)=>{
         caseResults.push(payload);
         phaseTrackers?.get(trackerKey(payload.project, payload.testPath))?.recordCaseResult(payload);
         await sinkForProjectName(payload.project).onTestCaseResult(payload);
-        if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
+        silentConsoleControllerForProjectName(payload.project).flushBufferedLogsForTask({
             taskId: payload.testId,
             status: payload.status,
             taskParentNames: payload.parentNames,
@@ -4902,7 +5395,7 @@ const runBrowserController = async (context, options)=>{
                 phaseTrackers.delete(key);
             }
         }
-        if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
+        silentConsoleControllerForProjectName(payload.project).flushBufferedLogsForTask({
             taskId: payload.testId,
             status: payload.status,
             taskParentNames: payload.parentNames,
@@ -4924,7 +5417,7 @@ const runBrowserController = async (context, options)=>{
             type: payload.type,
             trace: payload.trace
         };
-        silentConsoleController.onConsoleLog(log);
+        silentConsoleControllerForProjectName(payload.projectName).onConsoleLog(log);
     };
     const handleFatal = async (payload)=>{
         const error = new Error(payload.message);
@@ -4971,6 +5464,10 @@ const runBrowserController = async (context, options)=>{
         context,
         allTestFiles,
         hostOptions,
+        projectRoots: new Map(projectRuntimeConfigs.map((project)=>[
+                project.name,
+                project.projectRoot
+            ])),
         isWatchMode,
         createDispatchRouter,
         fatalErrorRef,
@@ -4981,11 +5478,12 @@ const runBrowserController = async (context, options)=>{
         logWatchReady: ()=>logWatchReadyMessage(context, enableCliShortcuts),
         destroyRuntime: ()=>destroyBrowserRuntime(runtime)
     };
-    const { testTime, watchSession, close } = useHeadlessDirect ? await createHeadlessScheduler({
+    const { testTime, rawCoverage, watchSession, close } = useHeadlessDirect ? await createHeadlessScheduler({
         ...schedulerDeps,
         browser,
         browserLaunchOptions,
         projectServers: runtime.projectServers,
+        v8Coverage,
         projectRuntimeConfigs,
         watchState,
         handlers: {
@@ -4995,17 +5493,23 @@ const runBrowserController = async (context, options)=>{
     }) : await createHeadedScheduler({
         ...schedulerDeps,
         runtime,
+        v8Coverage,
         handlers: {
-            handleTestFileStart,
-            handleTestCaseResult,
-            handleTestFileComplete,
-            handleLog,
-            handleFatal
+            handleTestFileComplete
         }
     });
-    if (fatalErrorRef.current) return failWithError(fatalErrorRef.current, close);
+    watchState.hooksEnabled = void 0 !== watchSession;
+    if (fatalErrorRef.current) {
+        const errorResult = await failWithError(fatalErrorRef.current, close);
+        return {
+            ...errorResult,
+            rawCoverage,
+            loadAssetFiles: loadBrowserCoverageAssetFiles,
+            loadSourceMaps: loadBrowserCoverageSourceMaps,
+            watchSession
+        };
+    }
     context.updateReporterResultState(reporterResults, caseResults);
-    watchState.hooksEnabled = isWatchMode;
     return {
         results: reporterResults,
         testResults: caseResults,
@@ -5015,6 +5519,9 @@ const runBrowserController = async (context, options)=>{
             testTime
         },
         hasFailure: reporterResults.some((result)=>'fail' === result.status),
+        rawCoverage,
+        loadAssetFiles: loadBrowserCoverageAssetFiles,
+        loadSourceMaps: loadBrowserCoverageSourceMaps,
         getSourcemap: getBrowserSourcemap,
         resolveSourcemap: resolveBrowserSourcemap,
         close,
@@ -5083,7 +5590,6 @@ const listBrowserTests = async (context, options)=>{
             })),
             viewport: project.normalizedConfig.browser.viewport
         }));
-    const maxTestTimeoutForRpc = getMaxTestTimeoutForRpc(browserProjects);
     const hostOptions = {
         rootPath: normalize(context.rootPath),
         projects: projectRuntimeConfigs,
@@ -5092,7 +5598,7 @@ const listBrowserTests = async (context, options)=>{
         },
         mode: 'collect',
         debug: isDebug(),
-        rpcTimeout: maxTestTimeoutForRpc
+        rpcTimeout: -1
     };
     runtime.setContainerOptions(hostOptions);
     const browserContext = await browser.newContext({
@@ -5110,7 +5616,8 @@ const listBrowserTests = async (context, options)=>{
             resolveCollect = resolve;
         });
         const page = await browserContext.newPage();
-        await page.exposeFunction(DISPATCH_MESSAGE_TYPE, (message)=>{
+        await page.exposeFunction(DISPATCH_MESSAGE_TYPE, (envelope)=>{
+            const message = envelope.message;
             switch(message.type){
                 case 'collect-result':
                     {
@@ -5229,9 +5736,12 @@ async function createBrowserExecutor(context, options) {
                 buildTime: result.duration.buildTime,
                 testTime: result.duration.testTime
             },
-            coverage: {
-                map: map?.toJSON()
-            },
+            coverage: map?.files().length || result.rawCoverage?.length ? {
+                map: map?.toJSON(),
+                raw: result.rawCoverage,
+                loadAssetFiles: result.loadAssetFiles,
+                loadSourceMaps: result.loadSourceMaps
+            } : void 0,
             resolveSourcemap: result.resolveSourcemap
         };
     };