@rstest/browser 0.11.5 → 0.11.7

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, finalizeRunCycle, getNoTestFilesMessage, getNumCpus as browser_getNumCpus, getPrettyConsoleName, getSetupFiles, getTestEntries, hasUserRstestConfigPlugins, importMetaRstestDefine, initModifyRstestConfigHooks, isDebug, isTTY, loadCoverageProvider, logWatchReadyMessage, logger, pluginMockRuntime, prepareWatchRerunState, projectRuntimeConfig, resolveProjectBuildCache, resolveShardedEntries, resolveSnapshotPathDefault, resolveWorkerCount, rsbuild, serializableConfig } from "@rstest/core/internal/browser";
-import { existsSync } from "node:fs";
+import { 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, 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 { dirname, join, normalize, relative, resolve as external_pathe_resolve } from "pathe";
 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");
@@ -1654,218 +1655,6 @@ __webpack_require__.add({
         };
     }
 });
-const TYPE_REQUEST = "q";
-const TYPE_RESPONSE = "s";
-function createPromiseWithResolvers() {
-    let resolve;
-    let reject;
-    return {
-        promise: new Promise((res, rej)=>{
-            resolve = res;
-            reject = rej;
-        }),
-        resolve,
-        reject
-    };
-}
-const random = Math.random.bind(Math);
-const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-function nanoid(size = 21) {
-    let id = "";
-    let i = size;
-    while(i--)id += urlAlphabet[64 * random() | 0];
-    return id;
-}
-const DEFAULT_TIMEOUT = 6e4;
-const defaultSerialize = (i)=>i;
-const defaultDeserialize = defaultSerialize;
-const { clearTimeout: dist_clearTimeout, setTimeout: dist_setTimeout } = globalThis;
-function createBirpc($functions, options) {
-    const { post, on, off = ()=>{}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
-    let $closed = false;
-    const _rpcPromiseMap = /* @__PURE__ */ new Map();
-    let _promiseInit;
-    let rpc;
-    async function _call(method, args, event, optional) {
-        if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
-        const req = {
-            m: method,
-            a: args,
-            t: TYPE_REQUEST
-        };
-        if (optional) req.o = true;
-        const send = async (_req)=>post(serialize(_req));
-        if (event) return void await send(req);
-        if (_promiseInit) try {
-            await _promiseInit;
-        } finally{
-            _promiseInit = void 0;
-        }
-        let { promise, resolve, reject } = createPromiseWithResolvers();
-        const id = nanoid();
-        req.i = id;
-        let timeoutId;
-        async function handler(newReq = req) {
-            if (timeout >= 0) {
-                timeoutId = dist_setTimeout(()=>{
-                    try {
-                        if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
-                    } catch (e) {
-                        reject(e);
-                    }
-                    _rpcPromiseMap.delete(id);
-                }, timeout);
-                if ("object" == typeof timeoutId) timeoutId = timeoutId.unref?.();
-            }
-            _rpcPromiseMap.set(id, {
-                resolve,
-                reject,
-                timeoutId,
-                method
-            });
-            await send(newReq);
-            return promise;
-        }
-        try {
-            if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
-            else await handler();
-        } catch (e) {
-            if (options.onGeneralError?.call(rpc, e) !== true) throw e;
-            return;
-        } finally{
-            dist_clearTimeout(timeoutId);
-            _rpcPromiseMap.delete(id);
-        }
-        return promise;
-    }
-    const builtinMethods = {
-        $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),
-        $rejectPendingCalls,
-        get $closed () {
-            return $closed;
-        },
-        get $meta () {
-            return options.meta;
-        },
-        $close,
-        $functions
-    };
-    rpc = proxify ? new Proxy({}, {
-        get (_, method) {
-            if (Object.prototype.hasOwnProperty.call(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)) {
-                sendEvent.asEvent = sendEvent;
-                return sendEvent;
-            }
-            const sendCall = (...args)=>_call(method, args, false);
-            sendCall.asEvent = sendEvent;
-            return sendCall;
-        }
-    }) : builtinMethods;
-    function $close(customError) {
-        $closed = true;
-        _rpcPromiseMap.forEach(({ reject, method })=>{
-            const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
-            if (customError) {
-                customError.cause ??= error;
-                return reject(customError);
-            }
-            reject(error);
-        });
-        _rpcPromiseMap.clear();
-        off(onMessage);
-    }
-    function $rejectPendingCalls(handler) {
-        const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject })=>{
-            if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
-            return handler({
-                method,
-                reject
-            });
-        });
-        _rpcPromiseMap.clear();
-        return handlerResults;
-    }
-    async function onMessage(data, ...extra) {
-        let msg;
-        try {
-            msg = deserialize(data);
-        } catch (e) {
-            if (options.onGeneralError?.call(rpc, e) !== true) throw e;
-            return;
-        }
-        if (msg.t === TYPE_REQUEST) {
-            const { m: method, a: args, o: optional } = msg;
-            let result, error;
-            let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
-            if (optional) fn ||= ()=>void 0;
-            if (fn) try {
-                result = await fn.apply("rpc" === bind ? rpc : $functions, args);
-            } catch (e) {
-                error = e;
-            }
-            else error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
-            if (msg.i) {
-                if (error && options.onFunctionError) {
-                    if (true === options.onFunctionError.call(rpc, error, method, args)) return;
-                }
-                if (!error) try {
-                    await post(serialize({
-                        t: TYPE_RESPONSE,
-                        i: msg.i,
-                        r: result
-                    }), ...extra);
-                    return;
-                } catch (e) {
-                    error = e;
-                    if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
-                }
-                try {
-                    await post(serialize({
-                        t: TYPE_RESPONSE,
-                        i: msg.i,
-                        e: error
-                    }), ...extra);
-                } catch (e) {
-                    if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
-                }
-            }
-        } else {
-            const { i: ack, r: result, e: error } = msg;
-            const promise = _rpcPromiseMap.get(ack);
-            if (promise) {
-                dist_clearTimeout(promise.timeoutId);
-                if (error) promise.reject(error);
-                else promise.resolve(result);
-            }
-            _rpcPromiseMap.delete(ack);
-        }
-    }
-    _promiseInit = on(onMessage);
-    return rpc;
-}
-const DEFAULT_MAX_HEADLESS_WORKERS = 12;
-const resolveHeadlessWorkerCount = ({ command, maxWorkers, totalTasks, numCpus = browser_getNumCpus() })=>{
-    const base = Math.max(Math.min(DEFAULT_MAX_HEADLESS_WORKERS, numCpus - 1), 1);
-    return resolveWorkerCount({
-        command,
-        maxWorkers,
-        totalTasks,
-        recommended: base,
-        watchRecommended: Math.max(Math.floor(base / 2), 1),
-        numCpus
-    });
-};
-const getHeadlessConcurrency = (context, totalTests)=>resolveHeadlessWorkerCount({
-        command: context.command,
-        maxWorkers: context.normalizedConfig.pool.maxWorkers,
-        totalTasks: totalTests
-    });
 const toErrorMessage = (error)=>error instanceof Error ? error.message : String(error);
 class HostDispatchRouter {
     handlers = new Map();
@@ -1914,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,
@@ -2054,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."
@@ -2109,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.`);
@@ -2141,104 +1932,6 @@ const validateBrowserConfig = (context)=>{
     }
     reportUnsupportedBrowserOptions(context);
 };
-const createHeadedSerialTaskQueue = ()=>{
-    let queue = Promise.resolve();
-    const enqueue = (task)=>{
-        const next = queue.then(task);
-        queue = next.catch(()=>{});
-        return next;
-    };
-    return {
-        enqueue
-    };
-};
-const createHeadlessLatestRerunScheduler = (options)=>{
-    let pendingFiles = null;
-    let draining = null;
-    let latestEnqueueVersion = 0;
-    const runDrainLoop = async ()=>{
-        while(pendingFiles){
-            const nextFiles = pendingFiles;
-            pendingFiles = null;
-            try {
-                await options.runFiles(nextFiles);
-            } catch (error) {
-                try {
-                    await options.onError?.(error);
-                } catch  {}
-            }
-        }
-    };
-    const ensureDrainLoop = ()=>{
-        if (draining) return;
-        draining = runDrainLoop().finally(()=>{
-            draining = null;
-        });
-    };
-    return {
-        async enqueueLatest (files) {
-            const enqueueVersion = ++latestEnqueueVersion;
-            const activeRun = options.getActiveRun();
-            if (activeRun && !options.isRunCancelled(activeRun)) {
-                options.onInterrupt?.(activeRun);
-                options.invalidateActiveRun();
-                await options.interruptActiveRun(activeRun);
-            }
-            if (enqueueVersion !== latestEnqueueVersion) return;
-            pendingFiles = files;
-            ensureDrainLoop();
-        },
-        async whenIdle () {
-            await draining;
-        }
-    };
-};
-const attachHeadlessRunnerTransport = async (page, handlers)=>{
-    await page.exposeFunction(DISPATCH_MESSAGE_TYPE, handlers.onDispatchMessage);
-    await page.exposeFunction(DISPATCH_RPC_BRIDGE_NAME, handlers.onDispatchRpc);
-};
-const isRecord = (value)=>'object' == typeof value && null !== value;
-const readString = (value, key, label)=>{
-    const result = value[key];
-    if ('string' != typeof result) throw new Error(`Invalid browser RPC request: ${label} must be a string`);
-    return result;
-};
-const readUnknownArray = (value, key, label)=>{
-    const result = value[key];
-    if (!Array.isArray(result)) throw new Error(`Invalid browser RPC request: ${label} must be an array`);
-    return result;
-};
-const parseBrowserLocatorIR = (value, label)=>{
-    if (!isRecord(value)) throw new Error(`Invalid browser RPC request: ${label} must be an object`);
-    const steps = value.steps;
-    if (!Array.isArray(steps)) throw new Error(`Invalid browser RPC request: ${label}.steps must be an array`);
-    return value;
-};
-const validateBrowserRpcRequest = (payload)=>{
-    if (!isRecord(payload)) throw new Error('Invalid browser RPC request: payload must be an object');
-    const kind = readString(payload, 'kind', 'kind');
-    if ('locator' !== kind && 'expect' !== kind && 'config' !== kind) throw new Error(`Invalid browser RPC request: unsupported kind ${JSON.stringify(kind)}`);
-    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'),
-        args: readUnknownArray(payload, 'args', 'args')
-    };
-    const isNot = payload.isNot;
-    if (void 0 !== isNot) {
-        if ('boolean' != typeof isNot) throw new Error('Invalid browser RPC request: isNot must be a boolean');
-        request.isNot = isNot;
-    }
-    const timeout = payload.timeout;
-    if (void 0 !== timeout) {
-        if ('number' != typeof timeout) throw new Error('Invalid browser RPC request: timeout must be a number');
-        request.timeout = timeout;
-    }
-    return request;
-};
 const supportedLocatorActions = new Set([
     'click',
     'dblclick',
@@ -2660,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 }) {
@@ -2669,6 +2373,9 @@ const playwrightProviderImplementation = {
             providerOptions
         });
     },
+    createV8CoverageCollector ({ browserName }) {
+        return 'chromium' === browserName ? createPlaywrightV8CoverageCollector() : null;
+    },
     async dispatchRpc ({ containerPage, runnerPage, request, timeoutFallbackMs }) {
         return dispatchPlaywrightBrowserRpc({
             containerPage: containerPage,
@@ -2686,165 +2393,18 @@ function getBrowserProviderImplementation(provider) {
     if (!implementation) throw new Error(`Unsupported browser provider: ${String(provider)}`);
     return implementation;
 }
-const createCancelSignal = ()=>{
-    let settled = false;
-    let resolveSignal = ()=>{};
-    const signal = new Promise((resolve)=>{
-        resolveSignal = ()=>{
-            if (!settled) {
-                settled = true;
-                resolve();
-            }
-        };
-    });
-    return {
-        signal,
-        resolve: resolveSignal
-    };
-};
-const createRunSession = (token)=>{
-    const { signal, resolve } = createCancelSignal();
-    return {
-        token,
-        cancelled: false,
-        cancelSignal: signal,
-        signalCancel: resolve
-    };
-};
-class RunSessionLifecycle {
-    currentToken = 0;
-    active = null;
-    get activeSession() {
-        return this.active;
-    }
-    get activeToken() {
-        return this.currentToken;
-    }
-    createSession(factory) {
-        const session = factory(++this.currentToken);
-        this.active = session;
-        return session;
-    }
-    isTokenActive(token) {
-        return token === this.currentToken;
-    }
-    isTokenStale(token) {
-        return !this.isTokenActive(token);
-    }
-    invalidateActiveToken() {
-        this.currentToken += 1;
-        return this.currentToken;
-    }
-    clearIfActive(session) {
-        if (this.active === session) this.active = null;
-    }
-    async cancel(session, options) {
-        const waitForDone = options?.waitForDone ?? true;
-        if (!session.cancelled) {
-            session.cancelled = true;
-            session.signalCancel();
-            await options?.onCancel?.(session);
-        }
-        if (waitForDone) await session.done?.catch(()=>{});
-    }
-    async cancelActive(options) {
-        if (!this.active) return;
-        await this.cancel(this.active, options);
-    }
-}
-class RunnerSessionRegistry {
-    nextId = 0;
-    sessionsById = new Map();
-    sessionIdByTestFile = new Map();
-    register(input) {
-        const id = input.id ?? `runner-session-${++this.nextId}`;
-        const createdAt = input.createdAt ?? Date.now();
-        const record = {
-            ...input,
-            id,
-            createdAt
-        };
-        this.sessionsById.set(id, record);
-        this.sessionIdByTestFile.set(record.testFile, id);
-        return record;
-    }
-    getById(id) {
-        return this.sessionsById.get(id);
-    }
-    getByTestFile(testFile) {
-        const id = this.sessionIdByTestFile.get(testFile);
-        if (!id) return;
-        return this.sessionsById.get(id);
-    }
-    list() {
-        return Array.from(this.sessionsById.values());
-    }
-    listByRunToken(runToken) {
-        return this.list().filter((session)=>session.runToken === runToken);
-    }
-    deleteById(id) {
-        const record = this.sessionsById.get(id);
-        if (!record) return false;
-        this.sessionsById.delete(id);
-        if (this.sessionIdByTestFile.get(record.testFile) === id) this.sessionIdByTestFile.delete(record.testFile);
-        return true;
-    }
-    deleteByTestFile(testFile) {
-        const id = this.sessionIdByTestFile.get(testFile);
-        if (!id) return false;
-        return this.deleteById(id);
-    }
-    clear() {
-        this.sessionsById.clear();
-        this.sessionIdByTestFile.clear();
-    }
-}
-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 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
@@ -2852,179 +2412,129 @@ 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 currentFileMap = new Map(currentTestFiles.map((file)=>[
-            file.testPath,
-            file
-        ]));
-    const matchedAffectedFiles = normalizedAffectedTestFiles.map((testFile)=>currentFileMap.get(testFile)).filter((file)=>Boolean(file));
+    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 hostController_dirname = dirname(fileURLToPath(import.meta.url));
+const browserRsbuild_dirname = dirname(fileURLToPath(import.meta.url));
 const OPTIONS_PLACEHOLDER = '__RSTEST_OPTIONS_PLACEHOLDER__';
-let nextBrowserFilePid = 1000000000;
 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 ?? {};
 };
-const getFileTaskId = (testPath)=>`file:${testPath}`;
-const createDeferredPromise = ()=>{
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej)=>{
-        resolve = res;
-        reject = rej;
+const createBrowserWatchState = ()=>({
+        lastTestFiles: [],
+        hooksEnabled: false,
+        headedFileSetVersion: 1,
+        invalidation: new Map(),
+        pendingAffectedTestFiles: new Map(),
+        compileStartTimes: new Map(),
+        pendingBuildTimeMs: 0
     });
-    return {
-        promise,
-        resolve,
-        reject
+const drainPendingBuildTime = (watchState)=>{
+    const buildTime = watchState.pendingBuildTimeMs;
+    watchState.pendingBuildTimeMs = 0;
+    return buildTime;
+};
+const drainPendingAffectedTestFiles = (watchState)=>{
+    const affected = new Set();
+    for (const files of watchState.pendingAffectedTestFiles.values())for (const file of files)affected.add(file);
+    watchState.pendingAffectedTestFiles.clear();
+    return Array.from(affected);
+};
+const resolveViewport = (viewport)=>{
+    if (!viewport) return null;
+    if ('string' == typeof viewport) return resolveBrowserViewportPreset(viewport);
+    if ('number' == typeof viewport.width && Number.isFinite(viewport.width) && viewport.width > 0 && 'number' == typeof viewport.height && Number.isFinite(viewport.height) && viewport.height > 0) return {
+        width: viewport.width,
+        height: viewport.height
     };
+    return null;
 };
-class ContainerRpcManager {
-    wss;
-    ws = null;
-    rpc = null;
-    methods;
-    onDisconnect;
-    detachActiveSocketListeners = null;
-    constructor(wss, methods, onDisconnect){
-        this.wss = wss;
-        this.methods = methods;
-        this.onDisconnect = onDisconnect;
-        this.setupConnectionHandler();
-    }
-    updateMethods(methods, onDisconnect) {
-        this.methods = methods;
-        this.onDisconnect = onDisconnect;
-        if (this.ws && this.ws.readyState === this.ws.OPEN) this.attachWebSocket(this.ws);
-    }
-    setupConnectionHandler() {
-        this.wss.on('connection', (ws)=>{
-            logger.debug('[Browser UI] Container WebSocket connected');
-            logger.debug(`[Browser UI] Current ws: ${this.ws ? 'exists' : 'null'}, new ws: ${ws ? 'exists' : 'null'}`);
-            this.attachWebSocket(ws);
-        });
-    }
-    attachWebSocket(ws) {
-        this.detachActiveSocketListeners?.();
-        if (this.rpc && !this.rpc.$closed) this.rpc.$close(new Error('Container RPC transport reattached'));
-        this.ws = ws;
-        const messageHandlers = new WeakMap();
-        this.rpc = createBirpc(this.methods, {
-            timeout: -1,
-            post: (data)=>{
-                if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(data));
-            },
-            on: (fn)=>{
-                const handler = (message)=>{
-                    try {
-                        const data = JSON.parse(message.toString());
-                        fn(data);
-                    } catch  {}
-                };
-                messageHandlers.set(fn, handler);
-                ws.on('message', handler);
-            },
-            off: (fn)=>{
-                const handler = messageHandlers.get(fn);
-                if (!handler) return;
-                ws.off('message', handler);
-                messageHandlers.delete(fn);
-            }
-        });
-        const handleClose = ()=>{
-            if (this.ws === ws) this.ws = null;
-            this.detachActiveSocketListeners?.();
-            this.detachActiveSocketListeners = null;
-            if (this.rpc && !this.rpc.$closed) {
-                const disconnectError = new Error('Browser UI WebSocket disconnected before reload completed');
-                this.rpc.$close(disconnectError);
-                this.onDisconnect?.(disconnectError);
-            }
-            this.rpc = null;
-        };
-        ws.on('close', handleClose);
-        this.detachActiveSocketListeners = ()=>{
-            ws.off('close', handleClose);
-        };
-    }
-    get isConnected() {
-        return null !== this.ws && this.ws.readyState === this.ws.OPEN;
-    }
-    get currentWebSocket() {
-        return this.ws;
-    }
-    reattach(ws) {
-        this.attachWebSocket(ws);
-    }
-    async notifyTestFileUpdate(files) {
-        await this.rpc?.onTestFileUpdate(files);
-    }
-    async updateHostConfig(config) {
-        await this.rpc?.onHostConfigUpdate(config);
-    }
-    async reloadTestFile(testFile, testNamePattern) {
-        logger.debug(`[Browser UI] reloadTestFile called, rpc: ${this.rpc ? 'exists' : 'null'}, ws: ${this.ws ? 'exists' : 'null'}`);
-        if (!this.rpc) throw new Error('Browser UI RPC not available for reloadTestFile');
-        logger.debug(`[Browser UI] Calling reloadTestFile: ${testFile}`);
-        return this.rpc.reloadTestFile(testFile, testNamePattern);
-    }
-}
-const createBrowserWatchState = ()=>({
-        lastTestFiles: [],
-        hooksEnabled: false,
-        invalidation: new Map(),
-        pendingAffectedTestFiles: new Map(),
-        compileStartTimes: new Map(),
-        pendingBuildTimeMs: 0
-    });
-const drainPendingBuildTime = (watchState)=>{
-    const buildTime = watchState.pendingBuildTimeMs;
-    watchState.pendingBuildTimeMs = 0;
-    return buildTime;
-};
-const drainPendingAffectedTestFiles = (watchState)=>{
-    const affected = new Set();
-    for (const files of watchState.pendingAffectedTestFiles.values())for (const file of files)affected.add(file);
-    watchState.pendingAffectedTestFiles.clear();
-    return Array.from(affected);
-};
-const watchContext = {
-    runtime: null,
-    cleanupRegistered: false,
-    cleanupPromise: null
-};
-const resolveViewport = (viewport)=>{
-    if (!viewport) return null;
-    if ('string' == typeof viewport) return resolveBrowserViewportPreset(viewport);
-    if ('number' == typeof viewport.width && Number.isFinite(viewport.width) && viewport.width > 0 && 'number' == typeof viewport.height && Number.isFinite(viewport.height) && viewport.height > 0) return {
-        width: viewport.width,
-        height: viewport.height
-    };
-    return null;
-};
-const mapViewportByProject = (projects)=>{
-    const map = new Map();
-    for (const project of projects){
-        const viewport = resolveViewport(project.viewport);
-        if (viewport) map.set(project.name, viewport);
+const mapViewportByProject = (projects)=>{
+    const map = new Map();
+    for (const project of projects){
+        const viewport = resolveViewport(project.viewport);
+        if (viewport) map.set(project.name, viewport);
     }
     return map;
 };
-const ensureProcessExitCode = (code)=>{
-    if (void 0 === process.exitCode || 0 === process.exitCode) process.exitCode = code;
-};
 const castArray = (arr)=>{
     if (void 0 === arr) return [];
     return Array.isArray(arr) ? arr : [
@@ -3228,7 +2738,6 @@ const getBrowserRsbuildEnvironmentConfig = (project)=>({
         plugins: project.normalizedConfig.plugins,
         root: project.rootPath
     });
-const getMaxTestTimeoutForRpc = (projects)=>Math.max(...projects.map((p)=>p.normalizedConfig.testTimeout ?? DEFAULT_TEST_TIMEOUT));
 const getBrowserLaunchOptions = (project)=>({
         provider: project.normalizedConfig.browser.provider,
         browser: project.normalizedConfig.browser.browser,
@@ -3247,15 +2756,7 @@ const ensureConsistentBrowserLaunchOptions = (projects)=>{
     }
     return firstOptions;
 };
-const resolveProviderForTestPath = ({ testPath, browserProjects })=>{
-    const normalizedTestPath = normalize(testPath);
-    const sortedProjects = [
-        ...browserProjects
-    ].sort((a, b)=>b.rootPath.length - a.rootPath.length);
-    for (const project of sortedProjects)if (normalizedTestPath.startsWith(project.rootPath)) return project.provider;
-    throw new Error(`Cannot resolve browser provider for test path: ${JSON.stringify(testPath)}. Known project roots: ${JSON.stringify(sortedProjects.map((p)=>p.rootPath))}`);
-};
-const collectProjectEntries = async (context, browserProjects = getBrowserProjects(context))=>Promise.all(browserProjects.map(async (project)=>{
+const browserRsbuild_collectProjectEntries = async (context, browserProjects = getBrowserProjects(context))=>Promise.all(browserProjects.map(async (project)=>{
         const { normalizedConfig: { include, exclude, includeSource, setupFiles } } = project;
         const tests = await getTestEntries({
             include,
@@ -3273,16 +2774,16 @@ const collectProjectEntries = async (context, browserProjects = getBrowserProjec
             testFiles: Object.values(tests)
         };
     }));
-const resolveBrowserFile = (relativePath)=>{
+const resolveBrowserDistFile = (relativePath)=>{
     const candidates = [
-        external_pathe_resolve(hostController_dirname, '../src', relativePath),
-        external_pathe_resolve(hostController_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(hostController_dirname, 'browser-container');
+    const distPath = external_pathe_resolve(browserRsbuild_dirname, 'browser-container');
     if (existsSync(distPath)) return distPath;
     throw new Error(`Browser container build not found at ${distPath}. Please run "pnpm --filter @rstest/browser build".`);
 };
@@ -3424,27 +2925,7 @@ const destroyBrowserRuntime = async (runtime)=>{
         force: true
     }).catch(()=>{});
 };
-const cleanupWatchRuntime = ()=>{
-    if (watchContext.cleanupPromise) return watchContext.cleanupPromise;
-    watchContext.cleanupPromise = (async ()=>{
-        if (!watchContext.runtime) return;
-        await destroyBrowserRuntime(watchContext.runtime);
-        watchContext.runtime = null;
-    })();
-    return watchContext.cleanupPromise;
-};
-const registerWatchCleanup = (embedded)=>{
-    if (watchContext.cleanupRegistered) return;
-    watchContext.cleanupRegistered = true;
-    if (embedded) return;
-    for (const signal of FATAL_SIGNALS)process.once(signal, ()=>{
-        cleanupWatchRuntime();
-    });
-    process.once('exit', ()=>{
-        cleanupWatchRuntime();
-    });
-};
-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';
@@ -3508,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)})]`;
@@ -3596,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;
@@ -3634,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);
@@ -3661,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: {
@@ -3690,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);
@@ -3706,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;
                         },
@@ -3715,7 +3207,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                 }
             }
         ]);
-        if (isWatchMode && onTriggerRerun) rsbuildInstance.addPlugins([
+        if (isWatchMode) rsbuildInstance.addPlugins([
             {
                 name: 'rstest:browser-watch',
                 setup (api) {
@@ -3731,7 +3223,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                             if (watchState.hooksEnabled) watchState.pendingBuildTimeMs = Math.max(watchState.pendingBuildTimeMs, Date.now() - compileStart);
                         }
                         if (stats) {
-                            const [projectEntry] = await collectProjectEntries(context, [
+                            const [projectEntry] = await browserRsbuild_collectProjectEntries(context, [
                                 project
                             ]);
                             const entryTestFiles = new Set(collectWatchTestFiles(projectEntry ? [
@@ -3760,7 +3252,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                             }
                         }
                         if (!watchState.hooksEnabled) return;
-                        await onTriggerRerun();
+                        await watchState.triggerRerun?.();
                     });
                 }
             }
@@ -3909,166 +3401,1661 @@ async function resolveProjectEntries(context, shardedEntries, browserProjects) {
         }
         return projectEntries;
     }
-    return collectProjectEntries(context, browserProjects);
+    return browserRsbuild_collectProjectEntries(context, browserProjects);
 }
-const runBrowserController = async (context, options)=>{
-    const { allowEmptyRun = false, filesOnly = false, onTraceEvents, env } = options ?? {};
-    const buildStart = Date.now();
-    const isWatchMode = 'watch' === context.command;
-    const phaseTrackers = onTraceEvents ? new Map() : void 0;
-    const trackerKey = (project, testPath)=>`${project}\u0000${testPath}`;
-    const browserProjects = options?.projects ?? getBrowserProjects(context);
-    const useHeadlessDirect = browserProjects.every((project)=>project.normalizedConfig.browser.headless);
-    const browserSourceMapCache = new Map();
-    const isHttpLikeFile = (file)=>/^https?:\/\//.test(file);
-    const resolveBrowserSourcemap = async (sourcePath)=>{
-        if (!isHttpLikeFile(sourcePath)) return {
-            handled: false,
-            sourcemap: null
-        };
-        const normalizedUrl = normalizeJavaScriptUrl(sourcePath);
-        if (!normalizedUrl) return {
-            handled: true,
-            sourcemap: null
-        };
-        if (browserSourceMapCache.has(normalizedUrl)) return {
-            handled: true,
-            sourcemap: browserSourceMapCache.get(normalizedUrl) ?? null
-        };
-        return {
-            handled: true,
-            sourcemap: await loadSourceMapWithCache({
-                jsUrl: normalizedUrl,
-                cache: browserSourceMapCache
-            })
-        };
-    };
-    const getBrowserSourcemap = async (sourcePath)=>{
-        const result = await resolveBrowserSourcemap(sourcePath);
-        return result.handled ? result.sourcemap : null;
-    };
-    const buildErrorResult = async (error, close)=>{
-        const elapsed = Math.max(0, Date.now() - buildStart);
-        const errorResult = {
-            results: [],
-            testResults: [],
-            duration: {
-                totalTime: elapsed,
-                buildTime: elapsed,
-                testTime: 0
-            },
-            hasFailure: true,
-            unhandledErrors: [
-                error
-            ],
-            getSourcemap: getBrowserSourcemap,
-            resolveSourcemap: resolveBrowserSourcemap,
-            close
-        };
-        if (isWatchMode) for (const reporter of context.reporters)await reporter.onTestRunEnd?.({
-            results: [],
-            testResults: [],
-            duration: errorResult.duration,
-            snapshotSummary: context.snapshotManager.summary,
-            getSourcemap: getBrowserSourcemap,
-            unhandledErrors: errorResult.unhandledErrors
-        });
-        return errorResult;
-    };
-    const toError = (error)=>error instanceof Error ? error : new Error(String(error));
-    const failWithError = async (error, cleanup)=>{
-        if (isWatchMode) ensureProcessExitCode(1);
-        const normalizedError = toError(error);
-        if (cleanup && !isWatchMode) return buildErrorResult(normalizedError, cleanup);
-        try {
-            return await buildErrorResult(normalizedError);
-        } finally{
-            await cleanup?.();
-        }
-    };
-    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 notifyTestRunStart = async ()=>{
-        if (!isWatchMode) return;
-        for (const reporter of context.reporters)await reporter.onTestRunStart?.();
-    };
-    const coverageConfig = browserProjects.find((project)=>project.normalizedConfig.coverage?.enabled)?.normalizedConfig.coverage;
-    const coverageProvider = coverageConfig?.enabled ? await createCoverageProvider(coverageConfig, context.rootPath) : null;
-    const notifyTestRunEnd = async ({ duration, coverage })=>{
-        if (!isWatchMode) return;
-        for (const reporter of context.reporters)await reporter.onTestRunEnd?.({
-            results: context.reporterResults.results,
-            coverage,
-            testResults: context.reporterResults.testResults,
-            duration,
-            snapshotSummary: context.snapshotManager.summary,
-            getSourcemap: getBrowserSourcemap
-        });
-    };
-    const containerDevServerEnv = process.env.RSTEST_CONTAINER_DEV_SERVER;
-    let containerDevServer;
-    let containerDistPath;
-    if (!useHeadlessDirect) {
-        if (containerDevServerEnv) try {
-            containerDevServer = new URL(containerDevServerEnv).toString();
-            logger.debug(`[Browser UI] Using dev server for container: ${containerDevServer}`);
-        } catch (error) {
-            const originalError = toError(error);
-            originalError.message = `Invalid RSTEST_CONTAINER_DEV_SERVER value: ${originalError.message}`;
-            return failWithError(originalError);
-        }
-        if (!containerDevServer) try {
-            containerDistPath = resolveContainerDist();
-        } catch (error) {
-            return failWithError(error);
-        }
+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;
     }
-    let projectEntries = await resolveProjectEntries(context, options?.shardedEntries, browserProjects);
-    let totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
-    const shouldInitializeEmptyBrowserHooks = 0 === totalTests && hasUserRstestConfigPlugins(browserProjects);
-    const createEmptyRunResult = ()=>{
-        const elapsed = Math.max(0, Date.now() - buildStart);
-        return {
-            results: [],
-            testResults: [],
-            duration: {
-                totalTime: elapsed,
-                buildTime: elapsed,
-                testTime: 0
-            },
-            hasFailure: false,
-            getSourcemap: getBrowserSourcemap,
-            resolveSourcemap: resolveBrowserSourcemap
-        };
-    };
-    const reportEmptyTestSet = ()=>{
-        const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
-        if (isWatchMode || !allowEmptyRun) {
-            const message = getNoTestFilesMessage({
-                context,
-                code,
-                defaultMessage: `No test files found, exiting with code ${code}.`
-            });
-            if (0 === code) logger.log(color.yellow(message));
-            else logger.error(color.red(message));
-            if (context.relatedFilters?.length) logger.log(color.gray('related: '), context.relatedFilters.join(color.gray(', ')));
-            else if (context.fileFilters?.length) logger.log(color.gray('filter: '), context.fileFilters.join(color.gray(', ')));
-        }
-        if (isWatchMode && 0 !== code && !allowEmptyRun) ensureProcessExitCode(code);
-    };
-    if (0 === totalTests && !shouldInitializeEmptyBrowserHooks) {
-        reportEmptyTestSet();
-        return allowEmptyRun ? createEmptyRunResult() : void 0;
+};
+const resolveInlineSourceMap = (code, sourceMapUrl)=>{
+    try {
+        const converter = convert_source_map.fromSource(code);
+        return converter ? flattenSourceMap(converter.toObject(), sourceMapUrl) : null;
+    } catch  {
+        return null;
     }
-    if (!filesOnly) await notifyTestRunStart();
-    const enableCliShortcuts = isWatchMode && isTTY('stdin');
-    const browserTempOutputRoot = context.normalizedConfig.output.distPath.root;
+};
+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;
+    return {
+        promise: new Promise((res, rej)=>{
+            resolve = res;
+            reject = rej;
+        }),
+        resolve,
+        reject
+    };
+}
+const random = Math.random.bind(Math);
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+    let id = "";
+    let i = size;
+    while(i--)id += urlAlphabet[64 * random() | 0];
+    return id;
+}
+const DEFAULT_TIMEOUT = 6e4;
+const defaultSerialize = (i)=>i;
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout: dist_clearTimeout, setTimeout: dist_setTimeout } = globalThis;
+function createBirpc($functions, options) {
+    const { post, on, off = ()=>{}, eventNames = [], serialize = defaultSerialize, deserialize = defaultDeserialize, resolver, bind = "rpc", timeout = DEFAULT_TIMEOUT, proxify = true } = options;
+    let $closed = false;
+    const _rpcPromiseMap = /* @__PURE__ */ new Map();
+    let _promiseInit;
+    let rpc;
+    async function _call(method, args, event, optional) {
+        if ($closed) throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+        const req = {
+            m: method,
+            a: args,
+            t: "q"
+        };
+        if (optional) req.o = true;
+        const send = async (_req)=>post(serialize(_req));
+        if (event) return void await send(req);
+        if (_promiseInit) try {
+            await _promiseInit;
+        } finally{
+            _promiseInit = void 0;
+        }
+        let { promise, resolve, reject } = createPromiseWithResolvers();
+        const id = nanoid();
+        req.i = id;
+        let timeoutId;
+        async function handler(newReq = req) {
+            if (timeout >= 0) {
+                timeoutId = dist_setTimeout(()=>{
+                    try {
+                        if (options.onTimeoutError?.call(rpc, method, args) !== true) throw new Error(`[birpc] timeout on calling "${method}"`);
+                    } catch (e) {
+                        reject(e);
+                    }
+                    _rpcPromiseMap.delete(id);
+                }, timeout);
+                if ("object" == typeof timeoutId) timeoutId = timeoutId.unref?.();
+            }
+            _rpcPromiseMap.set(id, {
+                resolve,
+                reject,
+                timeoutId,
+                method
+            });
+            await send(newReq);
+            return promise;
+        }
+        try {
+            if (options.onRequest) await options.onRequest.call(rpc, req, handler, resolve);
+            else await handler();
+        } catch (e) {
+            if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+            return;
+        } finally{
+            dist_clearTimeout(timeoutId);
+            _rpcPromiseMap.delete(id);
+        }
+        return promise;
+    }
+    const builtinMethods = {
+        $call: (method, ...args)=>_call(method, args, false),
+        $callOptional: (method, ...args)=>_call(method, args, false, true),
+        $callEvent: (method, ...args)=>_call(method, args, true),
+        $callRaw: (options)=>_call(options.method, options.args, options.event, options.optional),
+        $rejectPendingCalls,
+        get $closed () {
+            return $closed;
+        },
+        get $meta () {
+            return options.meta;
+        },
+        $close,
+        $functions
+    };
+    rpc = proxify ? new Proxy({}, {
+        get (_, 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)) {
+                sendEvent.asEvent = sendEvent;
+                return sendEvent;
+            }
+            const sendCall = (...args)=>_call(method, args, false);
+            sendCall.asEvent = sendEvent;
+            return sendCall;
+        }
+    }) : builtinMethods;
+    function $close(customError) {
+        $closed = true;
+        _rpcPromiseMap.forEach(({ reject, method })=>{
+            const error = /* @__PURE__ */ new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+            if (customError) {
+                customError.cause ??= error;
+                return reject(customError);
+            }
+            reject(error);
+        });
+        _rpcPromiseMap.clear();
+        off(onMessage);
+    }
+    function $rejectPendingCalls(handler) {
+        const handlerResults = Array.from(_rpcPromiseMap.values()).map(({ method, reject })=>{
+            if (!handler) return reject(/* @__PURE__ */ new Error(`[birpc]: rejected pending call "${method}".`));
+            return handler({
+                method,
+                reject
+            });
+        });
+        _rpcPromiseMap.clear();
+        return handlerResults;
+    }
+    async function onMessage(data, ...extra) {
+        let msg;
+        try {
+            msg = deserialize(data);
+        } catch (e) {
+            if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+            return;
+        }
+        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]);
+            if (optional) fn ||= ()=>void 0;
+            if (fn) try {
+                result = await fn.apply("rpc" === bind ? rpc : $functions, args);
+            } catch (e) {
+                error = e;
+            }
+            else error = /* @__PURE__ */ new Error(`[birpc] function "${method}" not found`);
+            if (msg.i) {
+                if (error && options.onFunctionError) {
+                    if (true === options.onFunctionError.call(rpc, error, method, args)) return;
+                }
+                if (!error) try {
+                    await post(serialize({
+                        t: "s",
+                        i: msg.i,
+                        r: result
+                    }), ...extra);
+                    return;
+                } catch (e) {
+                    error = e;
+                    if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+                }
+                try {
+                    await post(serialize({
+                        t: "s",
+                        i: msg.i,
+                        e: error
+                    }), ...extra);
+                } catch (e) {
+                    if (options.onGeneralError?.call(rpc, e, method, args) !== true) throw e;
+                }
+            }
+        } else {
+            const { i: ack, r: result, e: error } = msg;
+            const promise = _rpcPromiseMap.get(ack);
+            if (promise) {
+                dist_clearTimeout(promise.timeoutId);
+                if (error) promise.reject(error);
+                else promise.resolve(result);
+            }
+            _rpcPromiseMap.delete(ack);
+        }
+    }
+    _promiseInit = on(onMessage);
+    return rpc;
+}
+class ContainerRpcManager {
+    wss;
+    ws = null;
+    rpc = null;
+    methods;
+    onDisconnect;
+    onAttach;
+    detachActiveSocketListeners = null;
+    transportEpoch = 0;
+    constructor(wss, methods, onDisconnect, onAttach){
+        this.wss = wss;
+        this.methods = methods;
+        this.onDisconnect = onDisconnect;
+        this.onAttach = onAttach;
+        this.setupConnectionHandler();
+    }
+    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() {
+        this.wss.on('connection', (ws)=>{
+            logger.debug('[Browser UI] Container WebSocket connected');
+            logger.debug(`[Browser UI] Current ws: ${this.ws ? 'exists' : 'null'}, new ws: ${ws ? 'exists' : 'null'}`);
+            this.attachWebSocket(ws);
+        });
+    }
+    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, {
+            timeout: -1,
+            post: (data)=>{
+                if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(data));
+            },
+            on: (fn)=>{
+                const handler = (message)=>{
+                    try {
+                        const data = JSON.parse(message.toString());
+                        fn(data);
+                    } catch  {}
+                };
+                messageHandlers.set(fn, handler);
+                ws.on('message', handler);
+            },
+            off: (fn)=>{
+                const handler = messageHandlers.get(fn);
+                if (!handler) return;
+                ws.off('message', handler);
+                messageHandlers.delete(fn);
+            }
+        });
+        const handleClose = ()=>{
+            if (this.ws === ws) this.ws = null;
+            this.detachActiveSocketListeners?.();
+            this.detachActiveSocketListeners = null;
+            if (this.rpc && !this.rpc.$closed) {
+                const disconnectError = new Error('Browser UI WebSocket disconnected before reload completed');
+                this.rpc.$close(disconnectError);
+                this.onDisconnect?.(disconnectError);
+            }
+            this.rpc = null;
+        };
+        ws.on('close', handleClose);
+        this.detachActiveSocketListeners = ()=>{
+            ws.off('close', handleClose);
+        };
+    }
+    get isConnected() {
+        return null !== this.ws && this.ws.readyState === this.ws.OPEN;
+    }
+    get currentWebSocket() {
+        return this.ws;
+    }
+    reattach(ws) {
+        this.attachWebSocket(ws);
+    }
+    async notifyTestFileUpdate(files, version) {
+        await this.rpc?.onTestFileUpdate(files, version);
+    }
+    async updateHostConfig(config) {
+        await this.rpc?.onHostConfigUpdate(config);
+    }
+    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} (run ${runId})`);
+        await this.rpc.reloadTestFile(testFile, runId, testNamePattern);
+    }
+}
+const getFileTaskId = (testPath)=>`file:${testPath}`;
+const toError = (error)=>error instanceof Error ? error : new Error(String(error));
+const createDeferredPromise = ()=>{
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        promise,
+        resolve,
+        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)=>[
+            file.testPath,
+            file
+        ]));
+    for (const testPath of testPaths){
+        const normalizedTestPath = normalize(testPath);
+        const file = filesByPath.get(normalizedTestPath);
+        if (file) {
+            scope.push({
+                file,
+                testNamePattern: pendingTestNamePatterns.get(normalizedTestPath)
+            });
+            pendingTestNamePatterns.delete(normalizedTestPath);
+        }
+    }
+    return scope;
+};
+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 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 waitForFrameSet = async (version)=>{
+        if (ackedFrameSetVersion >= version) return;
+        await new Promise((resolve, reject)=>{
+            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)
+            };
+            frameSetWaiters.add(waiter);
+        });
+    };
+    const findTestFileInfo = (testFile)=>{
+        const normalizedTestFile = normalize(testFile);
+        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;
+        const created = await createContainerPage();
+        containerContext = created.context;
+        containerPage = created.page;
+        if (isWatchMode) {
+            runtime.containerPage = containerPage;
+            runtime.containerContext = containerContext;
+        }
+    }
+    setDispatchPageResolver(()=>({
+            containerPage
+        }));
+    const dispatchRouter = createDispatchRouter();
+    const headedReloadQueue = createHeadedSerialTaskQueue();
+    let rawCoverage = [];
+    let coverageProject;
+    let coverageStarted = false;
+    const startCoverage = async (projectName)=>{
+        if (!v8Coverage) return;
+        await v8Coverage.start(containerPage);
+        coverageStarted = true;
+        coverageProject = projectName;
+    };
+    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);
+    };
+    let enqueueHeadedReload = async (_file, _testNamePattern)=>{
+        throw new Error('Headed reload queue is not initialized');
+    };
+    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;
+        }
+        await containerPage.goto(containerUrl, {
+            waitUntil: 'load'
+        });
+        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)=>{
+        await startCoverage(file.projectName);
+        const { runId, settled } = runs.mint(file.testPath);
+        rpcManager.reloadTestFile(file.testPath, runId, testNamePattern).catch((error)=>runs.reject(runId, error));
+        try {
+            await settled;
+        } finally{
+            await collectCoverage().catch((error)=>{
+                logger.debug(`[Headed] Failed to flush coverage: ${error}`);
+            });
+        }
+    };
+    let runUiRequestedRerun = async (file, testNamePattern)=>{
+        await enqueueHeadedReload(file, testNamePattern);
+    };
+    const createRpcMethods = ()=>({
+            async rerunTest (testFile, testNamePattern) {
+                const projectName = context.normalizedConfig.name || 'project';
+                const relativePath = relative(context.rootPath, testFile);
+                const displayPath = `<${projectName}>/${relativePath}`;
+                logger.log(color.cyan(`\nRe-running test: ${displayPath}${testNamePattern ? ` (pattern: ${testNamePattern})` : ''}\n`));
+                await runUiRequestedRerun(getTestFileInfo(testFile), testNamePattern);
+            },
+            async getTestFiles () {
+                return {
+                    files: currentTestFiles,
+                    version: watchState.headedFileSetVersion
+                };
+            },
+            async onFrameSetReady (version) {
+                markFrameSetReady(version);
+            },
+            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) {
+                    coverageError = toError(error);
+                }
+                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(), runs.rejectAll, runs.setTransportEpoch);
+        const existingWs = rpcManager.currentWebSocket;
+        if (existingWs) rpcManager.reattach(existingWs);
+    } else {
+        rpcManager = new ContainerRpcManager(wss, createRpcMethods(), runs.rejectAll, runs.setTransportEpoch);
+        if (isWatchMode) runtime.rpcManager = rpcManager;
+    }
+    if (isNewPage) {
+        await containerPage.goto(containerUrl, {
+            waitUntil: 'load'
+        });
+        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 {
+            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;
+            }
+        } catch (error) {
+            fatalErrorRef.current = fatalErrorRef.current ?? toError(error);
+        }
+        testTime = Date.now() - testStart;
+    }
+    let watchSession;
+    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 = {
+                ...hostOptions,
+                snapshot: {
+                    updateSnapshot: context.snapshotManager.options.updateSnapshot
+                }
+            };
+            runtime.setContainerOptions(refreshedHostOptions);
+            await rpcManager.updateHostConfig(refreshedHostOptions);
+        };
+        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);
+                }
+                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;
+            }
+        };
+        const dispatchRerunQueue = createHeadedSerialTaskQueue();
+        watchSignals.setDispatchRerun(()=>dispatchRerunQueue.enqueue(runDispatchRerunOnce));
+        runUiRequestedRerun = async (file, testNamePattern)=>{
+            await refreshHostConfig();
+            const { cycle } = await watchSignals.signalInvalidation([
+                file.testPath
+            ], ()=>{
+                if (void 0 === testNamePattern) pendingTestNamePatterns.delete(normalize(file.testPath));
+                else pendingTestNamePatterns.set(normalize(file.testPath), testNamePattern);
+            });
+            await cycle;
+        };
+        watchSession = createWatchSession(runScope);
+    }
+    const closeContainerRuntime = isWatchMode ? void 0 : async ()=>{
+        try {
+            await containerPage.close();
+        } catch  {}
+        try {
+            await containerContext.close();
+        } catch  {}
+        await destroyRuntime();
+    };
+    return {
+        testTime,
+        rawCoverage,
+        watchSession,
+        close: closeContainerRuntime
+    };
+};
+const DEFAULT_MAX_HEADLESS_WORKERS = 12;
+const resolveHeadlessWorkerCount = ({ command, maxWorkers, totalTasks, numCpus = browser_getNumCpus() })=>{
+    const base = Math.max(Math.min(DEFAULT_MAX_HEADLESS_WORKERS, numCpus - 1), 1);
+    return resolveWorkerCount({
+        command,
+        maxWorkers,
+        totalTasks,
+        recommended: base,
+        watchRecommended: Math.max(Math.floor(base / 2), 1),
+        numCpus
+    });
+};
+const getHeadlessConcurrency = (context, totalTests)=>resolveHeadlessWorkerCount({
+        command: context.command,
+        maxWorkers: context.normalizedConfig.pool.maxWorkers,
+        totalTasks: totalTests
+    });
+const attachHeadlessRunnerTransport = async (page, handlers)=>{
+    await page.exposeFunction(DISPATCH_MESSAGE_TYPE, handlers.onDispatchMessage);
+    await page.exposeFunction(DISPATCH_RPC_BRIDGE_NAME, handlers.onDispatchRpc);
+};
+const createCancelSignal = ()=>{
+    let settled = false;
+    let resolveSignal = ()=>{};
+    const signal = new Promise((resolve)=>{
+        resolveSignal = ()=>{
+            if (!settled) {
+                settled = true;
+                resolve();
+            }
+        };
+    });
+    return {
+        signal,
+        resolve: resolveSignal
+    };
+};
+const createRunSession = (token)=>{
+    const { signal, resolve } = createCancelSignal();
+    return {
+        token,
+        cancelled: false,
+        cancelSignal: signal,
+        signalCancel: resolve
+    };
+};
+class RunSessionLifecycle {
+    currentToken = 0;
+    active = null;
+    get activeSession() {
+        return this.active;
+    }
+    get activeToken() {
+        return this.currentToken;
+    }
+    createSession(factory) {
+        const session = factory(++this.currentToken);
+        this.active = session;
+        return session;
+    }
+    isTokenActive(token) {
+        return token === this.currentToken;
+    }
+    isTokenStale(token) {
+        return !this.isTokenActive(token);
+    }
+    invalidateActiveToken() {
+        this.currentToken += 1;
+        return this.currentToken;
+    }
+    clearIfActive(session) {
+        if (this.active === session) this.active = null;
+    }
+    async cancel(session, options) {
+        const waitForDone = options?.waitForDone ?? true;
+        if (!session.cancelled) {
+            session.cancelled = true;
+            session.signalCancel();
+            await options?.onCancel?.(session);
+        }
+        if (waitForDone) await session.done?.catch(()=>{});
+    }
+    async cancelActive(options) {
+        if (!this.active) return;
+        await this.cancel(this.active, options);
+    }
+}
+class RunnerSessionRegistry {
+    nextId = 0;
+    sessionsById = new Map();
+    sessionIdByTestFile = new Map();
+    register(input) {
+        const id = input.id ?? `runner-session-${++this.nextId}`;
+        const createdAt = input.createdAt ?? Date.now();
+        const record = {
+            ...input,
+            id,
+            createdAt
+        };
+        this.sessionsById.set(id, record);
+        this.sessionIdByTestFile.set(record.testFile, id);
+        return record;
+    }
+    getById(id) {
+        return this.sessionsById.get(id);
+    }
+    getByTestFile(testFile) {
+        const id = this.sessionIdByTestFile.get(testFile);
+        if (!id) return;
+        return this.sessionsById.get(id);
+    }
+    list() {
+        return Array.from(this.sessionsById.values());
+    }
+    listByRunToken(runToken) {
+        return this.list().filter((session)=>session.runToken === runToken);
+    }
+    deleteById(id) {
+        const record = this.sessionsById.get(id);
+        if (!record) return false;
+        this.sessionsById.delete(id);
+        if (this.sessionIdByTestFile.get(record.testFile) === id) this.sessionIdByTestFile.delete(record.testFile);
+        return true;
+    }
+    deleteByTestFile(testFile) {
+        const id = this.sessionIdByTestFile.get(testFile);
+        if (!id) return false;
+        return this.deleteById(id);
+    }
+    clear() {
+        this.sessionsById.clear();
+        this.sessionIdByTestFile.clear();
+    }
+}
+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)=>({
+            runnerPage: target?.sessionId ? sessionRegistry.getById(target.sessionId)?.page : void 0
+        }));
+    let dispatchRequestCounter = 0;
+    const nextDispatchRequestId = (namespace)=>`${namespace}-${++dispatchRequestCounter}`;
+    const closeContextSafely = async (browserContext)=>{
+        try {
+            await browserContext.close();
+        } catch  {}
+    };
+    const cancelRun = async (run, waitForDone = true)=>{
+        await runLifecycle.cancel(run, {
+            waitForDone,
+            onCancel: async (session)=>{
+                await Promise.all(Array.from(session.contexts).map((browserContext)=>closeContextSafely(browserContext)));
+            }
+        });
+    };
+    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"),
+            runToken: run.token,
+            namespace: "runner",
+            method: message.type,
+            args: 'payload' in message ? message.payload : void 0,
+            target: {
+                sessionId,
+                testFile: file.testPath,
+                projectName: file.projectName
+            }
+        });
+        if (response.stale) return;
+        if (response.error) throw new Error(response.error);
+    };
+    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({
+            providerOptions: browserLaunchOptions.providerOptions,
+            viewport: viewport ?? null
+        });
+        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;
+                resolveDone?.();
+            }
+        };
+        const donePromise = new Promise((resolve)=>{
+            resolveDone = resolve;
+        });
+        const crashDeferred = createDeferredPromise();
+        const onPageDead = (reason)=>{
+            if (settled || run.cancelled || !runLifecycle.isTokenActive(run.token)) return;
+            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({
+                testFile: file.testPath,
+                projectName: file.projectName,
+                runToken: run.token,
+                mode: 'headless-page',
+                context: browserContext,
+                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 (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) markDone();
+                        else if ('fatal' === message.type) {
+                            markDone();
+                            await collectRunCoverage(run);
+                            await cancelRun(run, false);
+                        }
+                    } catch (error) {
+                        const formatted = toError(error);
+                        await handleFatal({
+                            message: formatted.message,
+                            stack: formatted.stack
+                        });
+                        markDone();
+                        await collectRunCoverage(run);
+                        await cancelRun(run, false);
+                    }
+                },
+                onDispatchRpc: async (request)=>dispatchRouter.dispatch({
+                        ...request,
+                        runToken: run.token,
+                        target: {
+                            sessionId: session.id,
+                            testFile: file.testPath,
+                            projectName: file.projectName,
+                            ...request.target
+                        }
+                    })
+            });
+            const inlineOptions = {
+                ...hostOptions,
+                snapshot: {
+                    updateSnapshot: context.snapshotManager.options.updateSnapshot
+                },
+                testFile: file.testPath,
+                runId: `${run.token}:${session.id}`
+            };
+            const serializedOptions = serializeForInlineScript(inlineOptions);
+            await page.addInitScript(`window.__RSTEST_BROWSER_OPTIONS__ = ${serializedOptions};`);
+            const projectServer = projectServers.get(file.projectName);
+            if (!projectServer) throw new Error(`No browser dev server for project "${file.projectName}" (test file: ${file.testPath}).`);
+            await page.goto(`http://localhost:${projectServer.port}/runner.html`, {
+                waitUntil: 'load'
+            });
+            const state = await Promise.race([
+                donePromise.then(()=>({
+                        type: 'done'
+                    })),
+                crashDeferred.promise.then((reason)=>({
+                        type: 'crash',
+                        reason
+                    })),
+                run.cancelSignal.then(()=>({
+                        type: 'cancelled'
+                    }))
+            ]);
+            if ('cancelled' === state.type) return;
+            if ('crash' === state.type && runLifecycle.isTokenActive(run.token) && !run.cancelled) {
+                await collectRunCoverage(run);
+                await handleFatal({
+                    message: state.reason
+                });
+                await cancelRun(run, false);
+            }
+        } catch (error) {
+            if (runLifecycle.isTokenActive(run.token) && !run.cancelled) {
+                await collectRunCoverage(run);
+                const formatted = toError(error);
+                await handleFatal({
+                    message: formatted.message,
+                    stack: formatted.stack
+                });
+                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 {
+                    await page.close();
+                } catch  {}
+                await closeContextSafely(browserContext);
+            };
+            if (sessionId) sessionRegistry.deleteById(sessionId);
+            run.contexts.delete(browserContext);
+            if (abandoned) teardown();
+            else await teardown();
+        }
+    };
+    const makeSkippedFileResult = (file)=>({
+            testId: getFileTaskId(file.testPath),
+            status: 'skip',
+            name: '',
+            testPath: file.testPath,
+            project: file.projectName,
+            results: []
+        });
+    const runFilesWithPool = async (files)=>{
+        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(),
+                coverageCollectors: new Set()
+            }));
+        const queue = [
+            ...files
+        ];
+        const concurrency = getHeadlessConcurrency(context, queue.length);
+        const bail = context.normalizedConfig.bail;
+        const worker = async ()=>{
+            while(queue.length > 0 && !run.cancelled && runLifecycle.isTokenActive(run.token)){
+                if (bail && context.stateManager.getCountOfFailedTests() >= bail) {
+                    let skipped = queue.shift();
+                    while(skipped){
+                        await handleTestFileComplete(makeSkippedFileResult(skipped));
+                        skipped = queue.shift();
+                    }
+                    return;
+                }
+                const next = queue.shift();
+                if (!next) return;
+                await runSingleFile(run, next, rawCoverage);
+            }
+        };
+        run.done = Promise.all(Array.from({
+            length: Math.min(queue.length, Math.max(concurrency, 1))
+        }, ()=>worker())).then(()=>{});
+        await run.done;
+        runLifecycle.clearIfActive(run);
+        return rawCoverage;
+    };
+    const testStart = Date.now();
+    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)));
+            return runFilesWithPool(watchState.lastTestFiles.filter((file)=>pathSet.has(file.testPath)));
+        };
+        watchSignals.setInterrupt(async ()=>{
+            const active = runLifecycle.activeSession;
+            if (!active || active.cancelled) return;
+            runLifecycle.invalidateActiveToken();
+            await runLifecycle.cancel(active, {
+                waitForDone: false
+            });
+        });
+        watchSignals.setDispatchRerun(async ()=>{
+            const newProjectEntries = await collectProjectEntries();
+            const rerunPlan = planWatchRerun({
+                projectEntries: newProjectEntries,
+                previousTestFiles: watchState.lastTestFiles,
+                affectedTestFiles: drainPendingAffectedTestFiles(watchState)
+            });
+            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);
+    }
+    const closeHeadlessRuntime = isWatchMode ? void 0 : async ()=>{
+        sessionRegistry.clear();
+        await destroyRuntime();
+    };
+    return {
+        testTime,
+        rawCoverage,
+        watchSession,
+        close: closeHeadlessRuntime
+    };
+};
+const isRecord = (value)=>'object' == typeof value && null !== value;
+const readString = (value, key, label)=>{
+    const result = value[key];
+    if ('string' != typeof result) throw new Error(`Invalid browser RPC request: ${label} must be a string`);
+    return result;
+};
+const readUnknownArray = (value, key, label)=>{
+    const result = value[key];
+    if (!Array.isArray(result)) throw new Error(`Invalid browser RPC request: ${label} must be an array`);
+    return result;
+};
+const parseBrowserLocatorIR = (value, label)=>{
+    if (!isRecord(value)) throw new Error(`Invalid browser RPC request: ${label} must be an object`);
+    const steps = value.steps;
+    if (!Array.isArray(steps)) throw new Error(`Invalid browser RPC request: ${label}.steps must be an array`);
+    return value;
+};
+const validateBrowserRpcRequest = (payload)=>{
+    if (!isRecord(payload)) throw new Error('Invalid browser RPC request: payload must be an object');
+    const kind = readString(payload, 'kind', 'kind');
+    if ('locator' !== kind && 'expect' !== kind && 'config' !== kind) throw new Error(`Invalid browser RPC request: unsupported kind ${JSON.stringify(kind)}`);
+    const request = {
+        id: readString(payload, 'id', 'id'),
+        testPath: readString(payload, 'testPath', 'testPath'),
+        kind,
+        locator: parseBrowserLocatorIR(payload.locator, 'locator'),
+        method: readString(payload, 'method', 'method'),
+        args: readUnknownArray(payload, 'args', 'args')
+    };
+    const isNot = payload.isNot;
+    if (void 0 !== isNot) {
+        if ('boolean' != typeof isNot) throw new Error('Invalid browser RPC request: isNot must be a boolean');
+        request.isNot = isNot;
+    }
+    const timeout = payload.timeout;
+    if (void 0 !== timeout) {
+        if ('number' != typeof timeout) throw new Error('Invalid browser RPC request: timeout must be a number');
+        request.timeout = timeout;
+    }
+    return request;
+};
+const watchContext = {
+    runtime: null,
+    cleanupRegistered: false,
+    cleanupPromise: null
+};
+const runWatchRuntimeTeardown = (state, destroy)=>{
+    if (state.cleanupPromise) return state.cleanupPromise;
+    state.cleanupPromise = (async ()=>{
+        if (!state.runtime) return;
+        await destroy(state.runtime);
+        state.runtime = null;
+    })();
+    return state.cleanupPromise.finally(()=>{
+        state.cleanupPromise = null;
+    });
+};
+const cleanupWatchRuntime = ()=>runWatchRuntimeTeardown(watchContext, destroyBrowserRuntime);
+const registerWatchCleanup = (embedded)=>{
+    if (watchContext.cleanupRegistered) return;
+    watchContext.cleanupRegistered = true;
+    if (embedded) return;
+    for (const signal of FATAL_SIGNALS)process.once(signal, ()=>{
+        cleanupWatchRuntime();
+    });
+    process.once('exit', ()=>{
+        cleanupWatchRuntime();
+    });
+};
+const createWatchSignals = (onInvalidate)=>{
+    let dispatchRerun;
+    let interruptInFlightRun;
+    let signalledCycle;
+    return {
+        setDispatchRerun (fn) {
+            dispatchRerun = fn;
+        },
+        async runDispatchRerun () {
+            await dispatchRerun?.();
+        },
+        setInterrupt (fn) {
+            interruptInFlightRun = fn;
+        },
+        async signalInvalidation (fileFilters, claimScope) {
+            await interruptInFlightRun?.();
+            claimScope?.();
+            const cycle = Promise.resolve(onInvalidate?.({
+                isFirstBuild: false,
+                fileFilters
+            })).then(()=>{}, (error)=>{
+                logger.error(color.red('Browser Mode watch cycle failed:'), error);
+            });
+            signalledCycle = cycle;
+            return {
+                cycle
+            };
+        },
+        async awaitSignalledCycle () {
+            await signalledCycle;
+        }
+    };
+};
+let nextBrowserFilePid = 1000000000;
+const resolveEmptyLaunchExitCode = (current, { allowEmptyRun, isWatchMode, passWithNoTests })=>{
+    if (allowEmptyRun || !isWatchMode || passWithNoTests) return current;
+    return void 0 === current || 0 === current ? 1 : current;
+};
+const getMaxTestTimeoutForRpc = (projects)=>Math.max(...projects.map((p)=>p.normalizedConfig.testTimeout ?? DEFAULT_TEST_TIMEOUT));
+const resolveProviderForTestPath = ({ testPath, browserProjects })=>{
+    const normalizedTestPath = normalize(testPath);
+    const sortedProjects = [
+        ...browserProjects
+    ].sort((a, b)=>b.rootPath.length - a.rootPath.length);
+    for (const project of sortedProjects)if (normalizedTestPath.startsWith(project.rootPath)) return project.provider;
+    throw new Error(`Cannot resolve browser provider for test path: ${JSON.stringify(testPath)}. Known project roots: ${JSON.stringify(sortedProjects.map((p)=>p.rootPath))}`);
+};
+const runBrowserController = async (context, options)=>{
+    const { allowEmptyRun = false, filesOnly = false, onTraceEvents, env, onInvalidate } = options ?? {};
+    const buildStart = Date.now();
+    const isWatchMode = 'watch' === context.command;
+    const phaseTrackers = onTraceEvents ? new Map() : void 0;
+    const trackerKey = (project, testPath)=>`${project}\u0000${testPath}`;
+    const browserProjects = options?.projects ?? getBrowserProjects(context);
+    const useHeadlessDirect = browserProjects.every((project)=>project.normalizedConfig.browser.headless);
+    const browserSourceMapCache = new Map();
+    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 {
+            handled: false,
+            sourcemap: null
+        };
+        const normalizedUrl = normalizeJavaScriptUrl(sourcePath);
+        if (!normalizedUrl) return {
+            handled: true,
+            sourcemap: null
+        };
+        if (browserSourceMapCache.has(normalizedUrl)) return {
+            handled: true,
+            sourcemap: browserSourceMapCache.get(normalizedUrl) ?? null
+        };
+        return {
+            handled: true,
+            sourcemap: await loadSourceMapWithCache({
+                jsUrl: normalizedUrl,
+                cache: browserSourceMapCache
+            })
+        };
+    };
+    const getBrowserSourcemap = async (sourcePath)=>{
+        const result = await resolveBrowserSourcemap(sourcePath);
+        return result.handled ? result.sourcemap : null;
+    };
+    const buildErrorResult = (error, close)=>{
+        const elapsed = Math.max(0, Date.now() - buildStart);
+        return {
+            results: [],
+            testResults: [],
+            duration: {
+                totalTime: elapsed,
+                buildTime: elapsed,
+                testTime: 0
+            },
+            hasFailure: true,
+            unhandledErrors: [
+                error
+            ],
+            getSourcemap: getBrowserSourcemap,
+            resolveSourcemap: resolveBrowserSourcemap,
+            close
+        };
+    };
+    const failWithError = async (error, cleanup)=>{
+        const normalizedError = toError(error);
+        if (cleanup && !isWatchMode) return buildErrorResult(normalizedError, cleanup);
+        try {
+            return buildErrorResult(normalizedError);
+        } finally{
+            await cleanup?.();
+        }
+    };
+    const coverageConfig = browserProjects.find((project)=>project.normalizedConfig.coverage?.enabled)?.normalizedConfig.coverage;
+    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;
+    if (!useHeadlessDirect) {
+        if (containerDevServerEnv) try {
+            containerDevServer = new URL(containerDevServerEnv).toString();
+            logger.debug(`[Browser UI] Using dev server for container: ${containerDevServer}`);
+        } catch (error) {
+            const originalError = toError(error);
+            originalError.message = `Invalid RSTEST_CONTAINER_DEV_SERVER value: ${originalError.message}`;
+            return failWithError(originalError);
+        }
+        if (!containerDevServer) try {
+            containerDistPath = resolveContainerDist();
+        } catch (error) {
+            return failWithError(error);
+        }
+    }
+    let projectEntries = await resolveProjectEntries(context, options?.shardedEntries, browserProjects);
+    let totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
+    const shouldInitializeEmptyBrowserHooks = 0 === totalTests && hasUserRstestConfigPlugins(browserProjects);
+    const createEmptyRunResult = ()=>{
+        const elapsed = Math.max(0, Date.now() - buildStart);
+        return {
+            results: [],
+            testResults: [],
+            duration: {
+                totalTime: elapsed,
+                buildTime: elapsed,
+                testTime: 0
+            },
+            hasFailure: false,
+            getSourcemap: getBrowserSourcemap,
+            resolveSourcemap: resolveBrowserSourcemap
+        };
+    };
+    const writeEmptyLaunchExitCode = ()=>{
+        process.exitCode = resolveEmptyLaunchExitCode(process.exitCode, {
+            allowEmptyRun,
+            isWatchMode,
+            passWithNoTests: context.normalizedConfig.passWithNoTests
+        });
+    };
+    if (0 === totalTests && !shouldInitializeEmptyBrowserHooks) {
+        writeEmptyLaunchExitCode();
+        return allowEmptyRun ? createEmptyRunResult() : void 0;
+    }
+    const enableCliShortcuts = isWatchMode && isTTY('stdin');
+    const browserTempOutputRoot = context.normalizedConfig.output.distPath.root;
     const tempDir = isWatchMode && watchContext.runtime ? watchContext.runtime.tempDir : isWatchMode ? join(context.rootPath, browserTempOutputRoot, 'browser', 'watch') : join(context.rootPath, browserTempOutputRoot, 'browser', Date.now().toString());
     let runtime = isWatchMode ? watchContext.runtime : null;
-    let triggerRerun;
-    let awaitHeadlessRerunIdle;
+    const watchSignals = createWatchSignals(onInvalidate);
     if (!runtime) {
         try {
             runtime = await createBrowserRuntime({
@@ -4079,12 +5066,9 @@ const runBrowserController = async (context, options)=>{
                 freezeShardedEntries: options?.freezeShardedEntries,
                 tempDir,
                 isWatchMode,
-                onTriggerRerun: isWatchMode ? async ()=>{
-                    await triggerRerun?.();
-                } : void 0,
                 containerDistPath,
                 containerDevServer,
-                skipProviderLaunch: filesOnly,
+                skipProviderLaunch: filesOnly || Boolean(browserCoverageCapabilityError),
                 appliedModifyRstestConfigEnvironments: options?.appliedModifyRstestConfigEnvironments
             });
         } catch (error) {
@@ -4095,13 +5079,18 @@ const runBrowserController = async (context, options)=>{
                 }).catch(()=>{});
             });
         }
-        if (isWatchMode) {
+        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;
@@ -4114,22 +5103,11 @@ const runBrowserController = async (context, options)=>{
         }
         return seeded;
     };
-    const watchHandles = isWatchMode ? {
-        rerun: async (testPaths)=>{
-            const seeded = seedPendingRerun(testPaths);
-            if (testPaths && 0 === seeded) return;
-            await triggerRerun?.();
-            await awaitHeadlessRerunIdle?.();
-        },
-        close: cleanupWatchRuntime
-    } : void 0;
-    const finalizeWatchRerun = async ({ rerunTestPaths, testTime, unhandledErrors })=>{
+    const buildRerunOutcome = ({ rerunTestPaths, testTime, rawCoverage, unhandledErrors })=>{
         const rerunPathSet = new Set(rerunTestPaths);
         const rerunResults = context.reporterResults.results.filter((result)=>rerunPathSet.has(result.testPath));
-        let rerunCoverage;
         const coverageMap = buildBrowserCoverageMap(rerunResults, coverageProvider);
-        if (coverageMap && coverageMap.files().length > 0) rerunCoverage = coverageMap.toJSON();
-        const outcome = {
+        return {
             results: rerunResults,
             testResults: context.reporterResults.testResults.filter((result)=>rerunPathSet.has(result.testPath)),
             errors: unhandledErrors ?? [],
@@ -4138,21 +5116,45 @@ const runBrowserController = async (context, options)=>{
                 buildTime: drainPendingBuildTime(watchState),
                 testTime
             },
-            coverage: rerunCoverage ? {
-                map: rerunCoverage
+            coverage: coverageMap?.files().length || rawCoverage.length ? {
+                map: coverageMap?.toJSON(),
+                raw: rawCoverage,
+                loadAssetFiles: loadBrowserCoverageAssetFiles,
+                loadSourceMaps: loadBrowserCoverageSourceMaps
             } : void 0,
             resolveSourcemap: resolveBrowserSourcemap
         };
-        await finalizeRunCycle(context, {
-            outcomes: [
-                outcome
-            ],
-            mode: 'on-demand',
-            isWatchMode: true,
-            coverageProvider,
-            reportOnFailure: coverageConfig?.reportOnFailure ?? false
-        });
     };
+    const createWatchSession = (execute)=>({
+            runCycle: async (testPaths)=>{
+                const rerunStartTime = Date.now();
+                fatalErrorRef.current = null;
+                let rerunError;
+                let rawCoverage = [];
+                try {
+                    rawCoverage = await execute(testPaths);
+                } catch (error) {
+                    rerunError = toError(error);
+                }
+                const rerunFatalError = fatalErrorRef.current ?? void 0;
+                return buildRerunOutcome({
+                    rerunTestPaths: testPaths,
+                    testTime: Math.max(0, Date.now() - rerunStartTime),
+                    rawCoverage,
+                    unhandledErrors: rerunError ? [
+                        rerunError
+                    ] : rerunFatalError ? [
+                        rerunFatalError
+                    ] : void 0
+                });
+            },
+            requestRerun: async (testPaths)=>{
+                const seeded = seedPendingRerun(testPaths);
+                if (testPaths && 0 === seeded) return;
+                await watchSignals.runDispatchRerun();
+                await watchSignals.awaitSignalledCycle();
+            }
+        });
     projectEntries = runtime.projectEntries;
     totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
     const buildTime = Date.now() - buildStart;
@@ -4170,11 +5172,15 @@ const runBrowserController = async (context, options)=>{
         close: ()=>destroyBrowserRuntime(runtime)
     };
     if (0 === totalTests) {
-        reportEmptyTestSet();
+        writeEmptyLaunchExitCode();
         await destroyBrowserRuntime(runtime);
         return allowEmptyRun ? createEmptyRunResult() : void 0;
     }
-    const { browser, browserLaunchOptions, wsPort, wss } = runtime;
+    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),
                 projectName: entry.project.name
@@ -4196,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),
@@ -4214,8 +5221,26 @@ 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));
-    let activeContainerPage = null;
-    let getHeadlessRunnerPageBySessionId;
+    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;
+    };
     const dispatchBrowserRpcRequest = async ({ request, target })=>{
         const timeoutFallbackMs = maxTestTimeoutForRpc;
         const provider = resolveProviderForTestPath({
@@ -4224,12 +5249,12 @@ const runBrowserController = async (context, options)=>{
         });
         const implementation = implementationByProvider.get(provider);
         if (!implementation) throw new Error(`Browser provider implementation not found: ${provider}`);
-        const runnerPage = target?.sessionId ? getHeadlessRunnerPageBySessionId?.(target.sessionId) : void 0;
+        const { runnerPage, containerPage } = resolveDispatchPages(target);
         if (target?.sessionId && !runnerPage) throw new Error(`Runner page session not found for browser dispatch: ${target.sessionId}`);
-        if (!runnerPage && !activeContainerPage) throw new Error('Browser container page is not initialized');
+        if (!runnerPage && !containerPage) throw new Error('Browser container page is not initialized');
         try {
             return await implementation.dispatchRpc({
-                containerPage: runnerPage ? void 0 : activeContainerPage ?? void 0,
+                containerPage: runnerPage ? void 0 : containerPage,
                 runnerPage,
                 request,
                 timeoutFallbackMs
@@ -4249,7 +5274,9 @@ const runBrowserController = async (context, options)=>{
     runtime.setContainerOptions(hostOptions);
     const reporterResults = [];
     const caseResults = [];
-    let fatalError = null;
+    const fatalErrorRef = {
+        current: null
+    };
     const runnerSinks = new Map(browserProjects.map((project)=>[
             project.name,
             createRunnerEventSink(context, project.normalizedConfig)
@@ -4259,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);
@@ -4321,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,
@@ -4337,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,
@@ -4360,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,
@@ -4368,7 +5403,6 @@ const runBrowserController = async (context, options)=>{
             testPath: payload.testPath
         });
         await sinkForProjectName(payload.project).onTestFileResult(payload);
-        if (isWatchMode && 'fail' === payload.status) ensureProcessExitCode(1);
     };
     const handleLog = async (payload)=>{
         const log = {
@@ -4383,13 +5417,12 @@ 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);
         error.stack = payload.stack;
-        fatalError = error;
-        if (isWatchMode) ensureProcessExitCode(1);
+        fatalErrorRef.current = error;
     };
     const runSnapshotRpc = async (request)=>{
         switch(request.method){
@@ -4427,637 +5460,73 @@ const runBrowserController = async (context, options)=>{
                 logger.debug(`[Dispatch] Skip registering dispatch namespace "${namespace}" because it is already reserved`);
             }
         });
-    if (useHeadlessDirect) {
-        const viewportByProject = mapViewportByProject(projectRuntimeConfigs);
-        const runLifecycle = new RunSessionLifecycle();
-        const sessionRegistry = new RunnerSessionRegistry();
-        getHeadlessRunnerPageBySessionId = (sessionId)=>sessionRegistry.getById(sessionId)?.page;
-        let dispatchRequestCounter = 0;
-        const nextDispatchRequestId = (namespace)=>`${namespace}-${++dispatchRequestCounter}`;
-        const closeContextSafely = async (browserContext)=>{
-            try {
-                await browserContext.close();
-            } catch  {}
-        };
-        const cancelRun = async (run, waitForDone = true)=>{
-            await runLifecycle.cancel(run, {
-                waitForDone,
-                onCancel: async (session)=>{
-                    await Promise.all(Array.from(session.contexts).map((browserContext)=>closeContextSafely(browserContext)));
-                }
-            });
-        };
-        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 dispatchRunnerMessage = async (run, file, sessionId, message)=>{
-            const response = await dispatchRouter.dispatch({
-                requestId: nextDispatchRequestId("runner"),
-                runToken: run.token,
-                namespace: "runner",
-                method: message.type,
-                args: 'payload' in message ? message.payload : void 0,
-                target: {
-                    sessionId,
-                    testFile: file.testPath,
-                    projectName: file.projectName
-                }
-            });
-            if (response.stale) return;
-            if (response.error) throw new Error(response.error);
-        };
-        const runSingleFile = async (run, file)=>{
-            if (run.cancelled || runLifecycle.isTokenStale(run.token)) return;
-            const viewport = viewportByProject.get(file.projectName);
-            const browserContext = await browser.newContext({
-                providerOptions: browserLaunchOptions.providerOptions,
-                viewport: viewport ?? null
-            });
-            run.contexts.add(browserContext);
-            let page = null;
-            let sessionId = null;
-            let settled = false;
-            let resolveDone = null;
-            const markDone = ()=>{
-                if (!settled) {
-                    settled = true;
-                    resolveDone?.();
-                }
-            };
-            const donePromise = new Promise((resolve)=>{
-                resolveDone = resolve;
-            });
-            const crashDeferred = createDeferredPromise();
-            const onPageDead = (reason)=>{
-                if (settled || run.cancelled || !runLifecycle.isTokenActive(run.token)) return;
-                settled = true;
-                crashDeferred.resolve(reason);
-            };
-            try {
-                page = await browserContext.newPage();
-                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({
-                    testFile: file.testPath,
-                    projectName: file.projectName,
-                    runToken: run.token,
-                    mode: 'headless-page',
-                    context: browserContext,
-                    page
-                });
-                sessionId = session.id;
-                await attachHeadlessRunnerTransport(page, {
-                    onDispatchMessage: async (message)=>{
-                        try {
-                            await dispatchRunnerMessage(run, file, session.id, message);
-                            if ('file-complete' === message.type || 'complete' === message.type) markDone();
-                            else if ('fatal' === message.type) {
-                                markDone();
-                                await cancelRun(run, false);
-                            }
-                        } catch (error) {
-                            const formatted = toError(error);
-                            await handleFatal({
-                                message: formatted.message,
-                                stack: formatted.stack
-                            });
-                            markDone();
-                            await cancelRun(run, false);
-                        }
-                    },
-                    onDispatchRpc: async (request)=>dispatchRouter.dispatch({
-                            ...request,
-                            runToken: run.token,
-                            target: {
-                                sessionId: session.id,
-                                testFile: file.testPath,
-                                projectName: file.projectName,
-                                ...request.target
-                            }
-                        })
-                });
-                const inlineOptions = {
-                    ...hostOptions,
-                    snapshot: {
-                        updateSnapshot: context.snapshotManager.options.updateSnapshot
-                    },
-                    testFile: file.testPath,
-                    runId: `${run.token}:${session.id}`
-                };
-                const serializedOptions = serializeForInlineScript(inlineOptions);
-                await page.addInitScript(`window.__RSTEST_BROWSER_OPTIONS__ = ${serializedOptions};`);
-                const projectServer = runtime.projectServers.get(file.projectName);
-                if (!projectServer) throw new Error(`No browser dev server for project "${file.projectName}" (test file: ${file.testPath}).`);
-                await page.goto(`http://localhost:${projectServer.port}/runner.html`, {
-                    waitUntil: 'load'
-                });
-                const state = await Promise.race([
-                    donePromise.then(()=>({
-                            type: 'done'
-                        })),
-                    crashDeferred.promise.then((reason)=>({
-                            type: 'crash',
-                            reason
-                        })),
-                    run.cancelSignal.then(()=>({
-                            type: 'cancelled'
-                        }))
-                ]);
-                if ('cancelled' === state.type) return;
-                if ('crash' === state.type && runLifecycle.isTokenActive(run.token) && !run.cancelled) {
-                    await handleFatal({
-                        message: state.reason
-                    });
-                    await cancelRun(run, false);
-                }
-            } catch (error) {
-                if (runLifecycle.isTokenActive(run.token) && !run.cancelled) {
-                    const formatted = toError(error);
-                    await handleFatal({
-                        message: formatted.message,
-                        stack: formatted.stack
-                    });
-                    await cancelRun(run, false);
-                }
-            } finally{
-                if (page) try {
-                    await page.close();
-                } catch  {}
-                if (sessionId) sessionRegistry.deleteById(sessionId);
-                run.contexts.delete(browserContext);
-                await closeContextSafely(browserContext);
-            }
-        };
-        const makeSkippedFileResult = (file)=>({
-                testId: getFileTaskId(file.testPath),
-                status: 'skip',
-                name: '',
-                testPath: file.testPath,
-                project: file.projectName,
-                results: []
-            });
-        const runFilesWithPool = async (files)=>{
-            if (0 === files.length) return;
-            const previous = runLifecycle.activeSession;
-            if (previous) await cancelRun(previous);
-            const run = runLifecycle.createSession((token)=>({
-                    ...createRunSession(token),
-                    contexts: new Set()
-                }));
-            const queue = [
-                ...files
-            ];
-            const concurrency = getHeadlessConcurrency(context, queue.length);
-            const bail = context.normalizedConfig.bail;
-            const worker = async ()=>{
-                while(queue.length > 0 && !run.cancelled && runLifecycle.isTokenActive(run.token)){
-                    if (bail && context.stateManager.getCountOfFailedTests() >= bail) {
-                        let skipped = queue.shift();
-                        while(skipped){
-                            await handleTestFileComplete(makeSkippedFileResult(skipped));
-                            skipped = queue.shift();
-                        }
-                        return;
-                    }
-                    const next = queue.shift();
-                    if (!next) return;
-                    await runSingleFile(run, next);
-                }
-            };
-            run.done = Promise.all(Array.from({
-                length: Math.min(queue.length, Math.max(concurrency, 1))
-            }, ()=>worker())).then(()=>{});
-            await run.done;
-            runLifecycle.clearIfActive(run);
-        };
-        const latestRerunScheduler = createHeadlessLatestRerunScheduler({
-            getActiveRun: ()=>runLifecycle.activeSession,
-            isRunCancelled: (run)=>run.cancelled,
-            invalidateActiveRun: ()=>{
-                runLifecycle.invalidateActiveToken();
-            },
-            interruptActiveRun: async (run)=>{
-                await cancelRun(run, false);
-            },
-            runFiles: async (files)=>{
-                prepareWatchRerunState(context);
-                await notifyTestRunStart();
-                const rerunStartTime = Date.now();
-                const fatalErrorBeforeRun = fatalError;
-                let rerunError;
-                try {
-                    await runFilesWithPool(files);
-                } catch (error) {
-                    rerunError = toError(error);
-                    throw error;
-                } finally{
-                    const testTime = Math.max(0, Date.now() - rerunStartTime);
-                    const rerunFatalError = fatalError && fatalError !== fatalErrorBeforeRun ? fatalError : void 0;
-                    await finalizeWatchRerun({
-                        rerunTestPaths: files.map((file)=>file.testPath),
-                        testTime,
-                        unhandledErrors: rerunError ? [
-                            rerunError
-                        ] : rerunFatalError ? [
-                            rerunFatalError
-                        ] : void 0
-                    });
-                    logWatchReadyMessage(context, enableCliShortcuts);
-                }
-            },
-            onError: async (error)=>{
-                const formatted = toError(error);
-                await handleFatal({
-                    message: formatted.message,
-                    stack: formatted.stack
-                });
-            },
-            onInterrupt: (run)=>{
-                logger.debug(`[Headless] Interrupting active run token ${run.token} before scheduling latest rerun`);
-            }
-        });
-        awaitHeadlessRerunIdle = ()=>latestRerunScheduler.whenIdle();
-        const testStart = Date.now();
-        await runFilesWithPool(allTestFiles);
-        const testTime = Date.now() - testStart;
-        if (isWatchMode) triggerRerun = async ()=>{
-            const newProjectEntries = await collectProjectEntries(context);
-            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;
-                if (0 === rerunPlan.currentTestFiles.length) {
-                    await latestRerunScheduler.enqueueLatest([]);
-                    logger.log(color.cyan('No browser test files remain after update.\n'));
-                    logWatchReadyMessage(context, enableCliShortcuts);
-                    return;
-                }
-                logger.log(color.cyan(`Test file set changed, re-running ${rerunPlan.currentTestFiles.length} file(s)...\n`));
-                await latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
-                return;
-            }
-            if (0 === rerunPlan.affectedTestFiles.length) {
-                logger.log(color.cyan('No affected browser test files detected, skipping re-run.\n'));
-                logWatchReadyMessage(context, enableCliShortcuts);
-                return;
-            }
-            logger.log(color.cyan(`Re-running ${rerunPlan.affectedTestFiles.length} affected test file(s)...\n`));
-            await latestRerunScheduler.enqueueLatest(rerunPlan.affectedTestFiles);
-        };
-        const closeHeadlessRuntime = isWatchMode ? void 0 : async ()=>{
-            sessionRegistry.clear();
-            await destroyBrowserRuntime(runtime);
-        };
-        if (fatalError) return failWithError(fatalError, closeHeadlessRuntime);
-        const duration = {
-            totalTime: buildTime + testTime,
-            buildTime,
-            testTime
-        };
-        context.updateReporterResultState(reporterResults, caseResults);
-        const isFailure = reporterResults.some((result)=>'fail' === result.status);
-        if (isWatchMode && isFailure) ensureProcessExitCode(1);
-        const cycleCoverageMap = isWatchMode && coverageProvider ? buildBrowserCoverageMap(reporterResults, coverageProvider) : void 0;
-        const result = {
-            results: reporterResults,
-            testResults: caseResults,
-            duration,
-            hasFailure: isFailure,
-            getSourcemap: getBrowserSourcemap,
-            resolveSourcemap: resolveBrowserSourcemap,
-            close: closeHeadlessRuntime,
-            coverage: cycleCoverageMap,
-            watch: watchHandles
-        };
-        if (isWatchMode) try {
-            await notifyTestRunEnd({
-                duration,
-                coverage: cycleCoverageMap?.files().length ? cycleCoverageMap.toJSON() : void 0
-            });
-        } finally{
-            await closeHeadlessRuntime?.();
-        }
-        if (isWatchMode && triggerRerun) {
-            watchState.hooksEnabled = true;
-            logWatchReadyMessage(context, enableCliShortcuts);
-        }
-        return result;
-    }
-    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();
-    };
-    const waitForRunnerFramesReady = async (testFiles)=>{
-        const signature = createTestFilesSignature(testFiles);
-        if (currentRunnerFramesSignature === signature) 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 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();
-        });
-    };
-    const getTestFileInfo = (testFile)=>{
-        const normalizedTestFile = normalize(testFile);
-        const fileInfo = currentTestFiles.find((file)=>file.testPath === normalizedTestFile);
-        if (!fileInfo) throw new Error(`Unknown browser test file: ${JSON.stringify(testFile)}`);
-        return fileInfo;
-    };
-    let containerContext;
-    let containerPage;
-    let isNewPage = false;
-    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(()=>{});
-        });
-        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}`));
-        });
-    }
-    activeContainerPage = 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');
-    };
-    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 rejectAllPendingHeadedReloads = (error)=>{
-        for (const [testPath, pending] of pendingHeadedReloads){
-            pendingHeadedReloads.delete(testPath);
-            pending.deferred.reject(error);
-        }
-    };
-    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 deferred = createDeferredPromise();
-        pendingHeadedReloads.set(testPath, {
-            runId,
-            deferred
-        });
-        return deferred.promise;
+    const schedulerDeps = {
+        context,
+        allTestFiles,
+        hostOptions,
+        projectRoots: new Map(projectRuntimeConfigs.map((project)=>[
+                project.name,
+                project.projectRoot
+            ])),
+        isWatchMode,
+        createDispatchRouter,
+        fatalErrorRef,
+        watchSignals,
+        setDispatchPageResolver,
+        createWatchSession,
+        collectProjectEntries: ()=>browserRsbuild_collectProjectEntries(context),
+        logWatchReady: ()=>logWatchReadyMessage(context, enableCliShortcuts),
+        destroyRuntime: ()=>destroyBrowserRuntime(runtime)
     };
-    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();
-    };
-    const reloadTestFileAndWait = async (file, testNamePattern)=>{
-        let reloadAck;
-        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;
+    const { testTime, rawCoverage, watchSession, close } = useHeadlessDirect ? await createHeadlessScheduler({
+        ...schedulerDeps,
+        browser,
+        browserLaunchOptions,
+        projectServers: runtime.projectServers,
+        v8Coverage,
+        projectRuntimeConfigs,
+        watchState,
+        handlers: {
+            handleFatal,
+            handleTestFileComplete
         }
-    };
-    const createRpcMethods = ()=>({
-            async rerunTest (testFile, testNamePattern) {
-                const projectName = context.normalizedConfig.name || 'project';
-                const relativePath = relative(context.rootPath, testFile);
-                const displayPath = `<${projectName}>/${relativePath}`;
-                logger.log(color.cyan(`\nRe-running test: ${displayPath}${testNamePattern ? ` (pattern: ${testNamePattern})` : ''}\n`));
-                await enqueueHeadedReload(getTestFileInfo(testFile), testNamePattern);
-            },
-            async getTestFiles () {
-                return currentTestFiles;
-            },
-            async onRunnerFramesReady (testFiles) {
-                markRunnerFramesReady(testFiles);
-            },
-            async onTestFileStart (payload) {
-                await handleTestFileStart(payload);
-            },
-            async onTestCaseResult (payload) {
-                await handleTestCaseResult(payload);
-            },
-            async onTestFileComplete (payload) {
-                try {
-                    await handleTestFileComplete(payload);
-                    resolvePendingHeadedReload(payload.testPath, payload.runId);
-                } catch (error) {
-                    rejectPendingHeadedReload(payload.testPath, toError(error), payload.runId);
-                    throw 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);
-            }
-        });
-    let rpcManager;
-    if (isWatchMode && runtime.rpcManager) {
-        rpcManager = runtime.rpcManager;
-        rpcManager.updateMethods(createRpcMethods(), rejectAllPendingHeadedReloads);
-        const existingWs = rpcManager.currentWebSocket;
-        if (existingWs) rpcManager.reattach(existingWs);
-    } else {
-        rpcManager = new ContainerRpcManager(wss, createRpcMethods(), rejectAllPendingHeadedReloads);
-        if (isWatchMode) runtime.rpcManager = rpcManager;
-    }
-    if (isNewPage) {
-        const pagePath = '/';
-        const containerPort = runtime.containerServer.port;
-        await containerPage.goto(`http://localhost:${containerPort}${pagePath}`, {
-            waitUntil: 'load'
-        });
-        logger.log(color.cyan(`\nBrowser mode opened at http://localhost:${containerPort}${pagePath}\n`));
-    }
-    enqueueHeadedReload = async (file, testNamePattern)=>headedReloadQueue.enqueue(async ()=>{
-            if (fatalError) return;
-            await reloadTestFileAndWait(file, testNamePattern);
-        });
-    let testTime = 0;
-    if (currentTestFiles.length > 0) {
-        const testStart = Date.now();
-        try {
-            await waitForRunnerFramesReady(currentTestFiles.map((file)=>file.testPath));
-            for (const file of currentTestFiles){
-                await enqueueHeadedReload(file);
-                if (fatalError) break;
-            }
-        } catch (error) {
-            fatalError = fatalError ?? toError(error);
-            if (isWatchMode) ensureProcessExitCode(1);
+    }) : await createHeadedScheduler({
+        ...schedulerDeps,
+        runtime,
+        v8Coverage,
+        handlers: {
+            handleTestFileComplete
         }
-        testTime = Date.now() - testStart;
-    }
-    if (isWatchMode) triggerRerun = async ()=>{
-        const refreshedHostOptions = {
-            ...hostOptions,
-            snapshot: {
-                updateSnapshot: context.snapshotManager.options.updateSnapshot
-            }
+    });
+    watchState.hooksEnabled = void 0 !== watchSession;
+    if (fatalErrorRef.current) {
+        const errorResult = await failWithError(fatalErrorRef.current, close);
+        return {
+            ...errorResult,
+            rawCoverage,
+            loadAssetFiles: loadBrowserCoverageAssetFiles,
+            loadSourceMaps: loadBrowserCoverageSourceMaps,
+            watchSession
         };
-        runtime.setContainerOptions(refreshedHostOptions);
-        const [, newProjectEntries] = await Promise.all([
-            rpcManager.updateHostConfig(refreshedHostOptions),
-            collectProjectEntries(context)
-        ]);
-        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'));
-                logWatchReadyMessage(context, enableCliShortcuts);
-                return;
-            }
-            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`));
-            prepareWatchRerunState(context);
-            await notifyTestRunStart();
-            const rerunStartTime = Date.now();
-            const fatalErrorBeforeRun = fatalError;
-            let rerunError;
-            try {
-                for (const testFile of rerunPlan.normalizedAffectedTestFiles)await enqueueHeadedReload(getTestFileInfo(testFile));
-            } catch (error) {
-                rerunError = toError(error);
-                throw error;
-            } finally{
-                const testTime = Math.max(0, Date.now() - rerunStartTime);
-                const rerunFatalError = fatalError && fatalError !== fatalErrorBeforeRun ? fatalError : void 0;
-                await finalizeWatchRerun({
-                    rerunTestPaths: rerunPlan.normalizedAffectedTestFiles,
-                    testTime,
-                    unhandledErrors: rerunError ? [
-                        rerunError
-                    ] : rerunFatalError ? [
-                        rerunFatalError
-                    ] : void 0
-                });
-                logWatchReadyMessage(context, enableCliShortcuts);
-            }
-        } else if (rerunPlan.filesChanged) logWatchReadyMessage(context, enableCliShortcuts);
-        else {
-            logger.log(color.cyan('Tests will be re-executed automatically\n'));
-            logWatchReadyMessage(context, enableCliShortcuts);
-        }
-    };
-    const closeContainerRuntime = isWatchMode ? void 0 : async ()=>{
-        try {
-            await containerPage.close();
-        } catch  {}
-        try {
-            await containerContext.close();
-        } catch  {}
-        await destroyBrowserRuntime(runtime);
-    };
-    if (fatalError) return failWithError(fatalError, closeContainerRuntime);
-    const duration = {
-        totalTime: buildTime + testTime,
-        buildTime,
-        testTime
-    };
+    }
     context.updateReporterResultState(reporterResults, caseResults);
-    const isFailure = reporterResults.some((result)=>'fail' === result.status);
-    if (isWatchMode && isFailure) ensureProcessExitCode(1);
-    const cycleCoverageMap = isWatchMode && coverageProvider ? buildBrowserCoverageMap(reporterResults, coverageProvider) : void 0;
-    const result = {
+    return {
         results: reporterResults,
         testResults: caseResults,
-        duration,
-        hasFailure: isFailure,
+        duration: {
+            totalTime: buildTime + testTime,
+            buildTime,
+            testTime
+        },
+        hasFailure: reporterResults.some((result)=>'fail' === result.status),
+        rawCoverage,
+        loadAssetFiles: loadBrowserCoverageAssetFiles,
+        loadSourceMaps: loadBrowserCoverageSourceMaps,
         getSourcemap: getBrowserSourcemap,
         resolveSourcemap: resolveBrowserSourcemap,
-        close: closeContainerRuntime,
-        coverage: cycleCoverageMap,
-        watch: watchHandles
+        close,
+        watchSession
     };
-    if (isWatchMode) try {
-        await notifyTestRunEnd({
-            duration,
-            coverage: cycleCoverageMap?.files().length ? cycleCoverageMap.toJSON() : void 0
-        });
-    } finally{
-        await closeContainerRuntime?.();
-    }
-    if (isWatchMode && triggerRerun) {
-        watchState.hooksEnabled = true;
-        logWatchReadyMessage(context, enableCliShortcuts);
-    }
-    return result;
 };
 const listBrowserTests = async (context, options)=>{
     const browserProjects = options?.projects ?? getBrowserProjects(context);
@@ -5116,11 +5585,11 @@ const listBrowserTests = async (context, options)=>{
             environmentName: project.environmentName,
             projectRoot: normalize(project.rootPath),
             runtimeConfig: serializableConfig(projectRuntimeConfig(project, {
-                envMode: 'static'
+                envMode: 'static',
+                envOverlay: options?.env
             })),
             viewport: project.normalizedConfig.browser.viewport
         }));
-    const maxTestTimeoutForRpc = getMaxTestTimeoutForRpc(browserProjects);
     const hostOptions = {
         rootPath: normalize(context.rootPath),
         projects: projectRuntimeConfigs,
@@ -5129,7 +5598,7 @@ const listBrowserTests = async (context, options)=>{
         },
         mode: 'collect',
         debug: isDebug(),
-        rpcTimeout: maxTestTimeoutForRpc
+        rpcTimeout: -1
     };
     runtime.setContainerOptions(hostOptions);
     const browserContext = await browser.newContext({
@@ -5147,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':
                     {
@@ -5249,8 +5719,11 @@ const emptyOutcome = ()=>({
     });
 async function createBrowserExecutor(context, options) {
     const { projects, coverageProvider, shardedEntries, freezeShardedEntries, filesOnly, allowEmptyRun, appliedModifyRstestConfigEnvironments } = options;
+    const isWatchMode = 'watch' === context.command;
     let deferredClose;
     let inFlightCycle;
+    let invalidationCallback;
+    let watchSession;
     const foldOutcome = (result)=>{
         if (!result) return emptyOutcome();
         const map = buildBrowserCoverageMap(result.results, coverageProvider);
@@ -5263,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
         };
     };
@@ -5274,6 +5750,15 @@ async function createBrowserExecutor(context, options) {
         projects,
         async init () {},
         async runCycle (opts) {
+            if (watchSession) {
+                const cycle = watchSession.runCycle(opts.fileFilters ?? []);
+                inFlightCycle = cycle;
+                try {
+                    return await cycle;
+                } finally{
+                    inFlightCycle = void 0;
+                }
+            }
             const cycle = runBrowserController(context, {
                 projects,
                 shardedEntries,
@@ -5282,24 +5767,37 @@ async function createBrowserExecutor(context, options) {
                 appliedModifyRstestConfigEnvironments,
                 onTraceEvents: opts.onTraceEvents,
                 env: opts.env,
-                updateSnapshot: opts.updateSnapshot
+                updateSnapshot: opts.updateSnapshot,
+                onInvalidate: isWatchMode ? (hint)=>invalidationCallback?.(hint) : void 0
             });
             inFlightCycle = cycle;
             try {
                 const result = await cycle;
                 deferredClose = result?.close;
+                watchSession = result?.watchSession;
                 return foldOutcome(result);
             } finally{
                 inFlightCycle = void 0;
             }
         },
-        async collect () {
+        onInvalidate (cb) {
+            invalidationCallback = cb;
+        },
+        hasWatchSession () {
+            return void 0 !== watchSession;
+        },
+        async requestRerun (testPaths) {
+            if (!watchSession) return void logger.log(color.yellow('\nBrowser Mode has no live watch session, so this rerun skipped it.'));
+            await watchSession.requestRerun(testPaths);
+        },
+        async collect (opts) {
             const pending = listBrowserTests(context, {
                 projects,
                 shardedEntries,
                 freezeShardedEntries,
                 filesOnly,
-                appliedModifyRstestConfigEnvironments
+                appliedModifyRstestConfigEnvironments,
+                env: opts.env
             });
             inFlightCycle = pending;
             try {
@@ -5314,6 +5812,11 @@ async function createBrowserExecutor(context, options) {
         },
         async close () {
             if (inFlightCycle) await inFlightCycle.catch(()=>void 0);
+            if (isWatchMode) {
+                watchSession = void 0;
+                await cleanupWatchRuntime();
+                return;
+            }
             const close = deferredClose;
             deferredClose = void 0;
             await close?.();