@rstest/browser 0.11.4 → 0.11.6

package/dist/index.js

@@ -1,10 +1,10 @@
-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, PhaseTracker, RSTEST_ENV_SYMBOL_KEY, applyWatchInvalidation, applyWebMockRspackConfig, browserIgnoredRuntimeConfigKeys, buildBrowserCoverageMap, color, createCoverageProvider, createRunnerEventSink, createSilentConsoleController, getNumCpus as browser_getNumCpus, getPrettyConsoleName, getSetupFiles, getTestEntries, hasUserRstestConfigPlugins, importMetaRstestDefine, initModifyRstestConfigHooks, isDebug, isTTY, loadCoverageProvider, logWatchReadyMessage, logger, pluginMockRuntime, projectRuntimeConfig, resolveProjectBuildCache, resolveShardedEntries, resolveSnapshotPathDefault, resolveWorkerCount, rsbuild, serializableConfig } from "@rstest/core/internal/browser";
 import promises from "node:fs/promises";
+import { dirname, 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 convert_source_map from "convert-source-map";
@@ -1654,218 +1654,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();
@@ -2141,104 +1929,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',
@@ -2686,159 +2376,9 @@ 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 collectDeletedTestPaths = (previous, current)=>{
+    const currentPathSet = new Set(current.map((file)=>file.testPath));
+    return previous.map((file)=>file.testPath).filter((testPath)=>!currentPathSet.has(testPath));
 };
 const serializeTestFiles = (files)=>JSON.stringify(files.map((f)=>`${f.projectName}:${f.testPath}`).sort());
 const normalizeTestFiles = (files)=>files.map((file)=>({
@@ -2854,11 +2394,8 @@ const planWatchRerun = ({ projectEntries, previousTestFiles, affectedTestFiles }
     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 affectedPathSet = new Set(normalizedAffectedTestFiles);
+    const matchedAffectedFiles = currentTestFiles.filter((file)=>affectedPathSet.has(file.testPath));
     return {
         currentTestFiles,
         filesChanged,
@@ -2869,162 +2406,49 @@ const planWatchRerun = ({ projectEntries, previousTestFiles, affectedTestFiles }
 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');
 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,
+        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 +2652,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 +2670,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,
@@ -3275,14 +2690,14 @@ const collectProjectEntries = async (context, browserProjects = getBrowserProjec
     }));
 const resolveBrowserFile = (relativePath)=>{
     const candidates = [
-        external_pathe_resolve(hostController_dirname, '../src', relativePath),
-        external_pathe_resolve(hostController_dirname, relativePath)
+        external_pathe_resolve(browserRsbuild_dirname, '../src', relativePath),
+        external_pathe_resolve(browserRsbuild_dirname, relativePath)
     ];
     for (const candidate of candidates)if (existsSync(candidate)) return candidate;
     throw new Error(`Unable to resolve browser client 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,26 +2839,6 @@ 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 containerHtmlTemplate = containerDistPath ? await promises.readFile(join(containerDistPath, 'index.html'), 'utf-8') : null;
     let injectedContainerHtml = null;
@@ -3549,6 +2944,30 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
             return false;
         }
     };
+    const serveContainerRoute = async (req, res, next)=>{
+        if (!req.url) return void next();
+        const url = new URL(req.url, 'http://localhost');
+        if ('/' === url.pathname) {
+            if (await respondWithDevServerHtml(url, res)) return;
+            const html = injectedContainerHtml || containerHtmlTemplate?.replace(OPTIONS_PLACEHOLDER, 'null');
+            if (html) {
+                res.setHeader('Content-Type', 'text/html');
+                res.end(html);
+                return;
+            }
+            res.statusCode = 502;
+            res.end('Container UI is not available.');
+            return;
+        }
+        if (url.pathname.startsWith('/container-static/')) {
+            if (await proxyDevServerAsset(req, res)) return;
+            if (serveContainer) return void serveContainer(req, res, next);
+            res.statusCode = 502;
+            res.end('Container assets are not available.');
+            return;
+        }
+        next();
+    };
     const buildProjectServer = async (project, isContainerServer)=>{
         const manifestPath = join(tempDir, toSafeVarName(project.environmentName), VIRTUAL_MANIFEST_FILENAME);
         const entry = getProjectEntry(project);
@@ -3585,7 +3004,10 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                 server: {
                     printUrls: false,
                     port: project.normalizedConfig.browser.port ?? (isContainerServer ? 4000 : 0),
-                    strictPort: project.normalizedConfig.browser.strictPort
+                    strictPort: project.normalizedConfig.browser.strictPort,
+                    setup: isContainerServer ? ({ server })=>{
+                        server.middlewares.use(serveContainerRoute);
+                    } : void 0
                 },
                 dev: createBrowserRsbuildDevConfig(enableHmr),
                 environments: {
@@ -3704,7 +3126,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 ? [
@@ -3800,27 +3222,6 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
                 }
                 return;
             }
-            if (isContainerServer) {
-                if ('/' === url.pathname) {
-                    if (await respondWithDevServerHtml(url, res)) return;
-                    const html = injectedContainerHtml || containerHtmlTemplate?.replace(OPTIONS_PLACEHOLDER, 'null');
-                    if (html) {
-                        res.setHeader('Content-Type', 'text/html');
-                        res.end(html);
-                        return;
-                    }
-                    res.statusCode = 502;
-                    res.end('Container UI is not available.');
-                    return;
-                }
-                if (url.pathname.startsWith('/container-static/')) {
-                    if (await proxyDevServerAsset(req, res)) return;
-                    if (serveContainer) return void serveContainer(req, res, next);
-                    res.statusCode = 502;
-                    res.end('Container assets are not available.');
-                    return;
-                }
-            }
             if ('/runner.html' === url.pathname) {
                 res.setHeader('Content-Type', 'text/html');
                 res.end(htmlTemplate);
@@ -3903,1209 +3304,1722 @@ async function resolveProjectEntries(context, shardedEntries, browserProjects) {
         }
         return projectEntries;
     }
-    return collectProjectEntries(context, browserProjects);
+    return browserRsbuild_collectProjectEntries(context, browserProjects);
 }
-const runBrowserController = async (context, options)=>{
-    const { allowEmptyWatchRun = false, allowEmptyRun = false, filesOnly = false, onTraceEvents, env } = options ?? {};
-    const buildStart = Date.now();
-    const isWatchMode = 'watch' === context.command;
-    const phaseTrackers = onTraceEvents ? new Map() : void 0;
-    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 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 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
+}
+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 (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);
+        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{
-            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, unhandledErrors, filterRerunTestPaths })=>{
-        if (!isWatchMode) return;
-        let mergedCoverage;
-        if (coverageProvider) {
-            const coverageMap = coverageProvider.createCoverageMap();
-            let hasCoverage = false;
-            for (const result of context.reporterResults.results)if (result.coverage) {
-                coverageMap.merge(result.coverage);
-                hasCoverage = true;
-            }
-            if (hasCoverage) mergedCoverage = coverageMap.toJSON();
+            _promiseInit = void 0;
         }
-        for (const reporter of context.reporters)await reporter.onTestRunEnd?.({
-            results: context.reporterResults.results,
-            coverage: mergedCoverage,
-            testResults: context.reporterResults.testResults,
-            duration,
-            snapshotSummary: context.snapshotManager.summary,
-            getSourcemap: getBrowserSourcemap,
-            unhandledErrors,
-            filterRerunTestPaths
-        });
-    };
-    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 shouldKeepWatchingWithEmptySet = isWatchMode && allowEmptyWatchRun;
-    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 = shouldKeepWatchingWithEmptySet ? 'No test files found.' : getNoTestFilesMessage({
-                context,
-                code,
-                defaultMessage: `No test files found, exiting with code ${code}.`
+        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
             });
-            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(', ')));
+            await send(newReq);
+            return promise;
         }
-        if (isWatchMode && 0 !== code && !shouldKeepWatchingWithEmptySet && !allowEmptyRun) ensureProcessExitCode(code);
-        return !shouldKeepWatchingWithEmptySet;
-    };
-    if (0 === totalTests && !shouldInitializeEmptyBrowserHooks) {
-        if (reportEmptyTestSet()) return allowEmptyRun ? createEmptyRunResult() : void 0;
-    }
-    if (!filesOnly) await notifyTestRunStart();
-    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;
-    if (!runtime) {
         try {
-            runtime = await createBrowserRuntime({
-                context,
-                projectEntries,
-                browserProjects,
-                shardedEntries: options?.shardedEntries,
-                freezeShardedEntries: options?.freezeShardedEntries,
-                tempDir,
-                isWatchMode,
-                onTriggerRerun: isWatchMode ? async ()=>{
-                    await triggerRerun?.();
-                } : void 0,
-                containerDistPath,
-                containerDevServer,
-                skipProviderLaunch: filesOnly,
-                appliedModifyRstestConfigEnvironments: options?.appliedModifyRstestConfigEnvironments
-            });
-        } catch (error) {
-            return failWithError(error, async ()=>{
-                await promises.rm(tempDir, {
-                    recursive: true,
-                    force: true
-                }).catch(()=>{});
-            });
-        }
-        if (isWatchMode) {
-            watchContext.runtime = runtime;
-            registerWatchCleanup(context.embedded);
+            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 watchState = runtime.watchState;
-    if (isWatchMode) watchState.lastTestFiles = collectWatchTestFiles(projectEntries);
-    const seedPendingRerun = (testPaths)=>{
-        const wanted = testPaths ? new Set(testPaths.map((testPath)=>normalize(testPath))) : null;
-        let seeded = 0;
-        for (const file of watchState.lastTestFiles){
-            if (wanted && !wanted.has(file.testPath)) continue;
-            const pending = watchState.pendingAffectedTestFiles.get(file.projectName) ?? new Set();
-            pending.add(file.testPath);
-            watchState.pendingAffectedTestFiles.set(file.projectName, pending);
-            seeded += 1;
-        }
-        return seeded;
-    };
-    const watchHandles = isWatchMode ? {
-        rerun: async (testPaths)=>{
-            const seeded = seedPendingRerun(testPaths);
-            if (testPaths && 0 === seeded) return;
-            await triggerRerun?.();
-            await awaitHeadlessRerunIdle?.();
+    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;
         },
-        close: cleanupWatchRuntime
-    } : void 0;
-    const finalizeWatchRerun = async ({ rerunTestPaths, testTime, unhandledErrors })=>{
-        const rerunPathSet = new Set(rerunTestPaths);
-        let sessionCoverage;
-        const coverageMap = buildBrowserCoverageMap(context.reporterResults.results, coverageProvider, {
-            keepResultCoverage: true
-        });
-        if (coverageMap && coverageMap.files().length > 0) sessionCoverage = coverageMap.toJSON();
-        const outcome = {
-            results: context.reporterResults.results.filter((result)=>rerunPathSet.has(result.testPath)),
-            testResults: context.reporterResults.testResults.filter((result)=>rerunPathSet.has(result.testPath)),
-            errors: unhandledErrors ?? [],
-            testPaths: rerunTestPaths,
-            duration: {
-                buildTime: drainPendingBuildTime(watchState),
-                testTime
-            },
-            coverage: sessionCoverage ? {
-                map: sessionCoverage
-            } : void 0,
-            resolveSourcemap: resolveBrowserSourcemap
-        };
-        await finalizeRunCycle(context, {
-            outcomes: [
-                outcome
-            ],
-            mode: 'on-demand',
-            isWatchMode: true,
-            coverageProvider,
-            reportOnFailure: coverageConfig?.reportOnFailure ?? false
-        });
-    };
-    projectEntries = runtime.projectEntries;
-    totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
-    const buildTime = Date.now() - buildStart;
-    if (filesOnly) return {
-        results: [],
-        testResults: [],
-        duration: {
-            totalTime: buildTime,
-            buildTime,
-            testTime: 0
+        get $meta () {
+            return options.meta;
         },
-        hasFailure: false,
-        getSourcemap: getBrowserSourcemap,
-        resolveSourcemap: resolveBrowserSourcemap,
-        close: ()=>destroyBrowserRuntime(runtime)
+        $close,
+        $functions
     };
-    if (0 === totalTests && reportEmptyTestSet()) {
-        await destroyBrowserRuntime(runtime);
-        return allowEmptyRun ? createEmptyRunResult() : void 0;
+    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);
     }
-    const { browser, browserLaunchOptions, wsPort, wss } = runtime;
-    const allTestFiles = projectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
-                testPath: normalize(testPath),
-                projectName: entry.project.name
-            })));
-    const projectRuntimeConfigs = browserProjects.map((project)=>({
-            name: project.name,
-            environmentName: project.environmentName,
-            projectRoot: normalize(project.rootPath),
-            runtimeConfig: serializableConfig(projectRuntimeConfig(project, {
-                envMode: 'static',
-                envOverlay: env
-            })),
-            viewport: project.normalizedConfig.browser.viewport
-        }));
-    const maxTestTimeoutForRpc = getMaxTestTimeoutForRpc(browserProjects);
-    const projectRunnerUrls = Object.fromEntries([
-        ...runtime.projectServers
-    ].map(([name, server])=>[
-            name,
-            `http://localhost:${server.port}`
-        ]));
-    const hostOptions = {
-        rootPath: normalize(context.rootPath),
-        projects: projectRuntimeConfigs,
-        snapshot: {
-            updateSnapshot: options?.updateSnapshot ?? context.snapshotManager.options.updateSnapshot
-        },
-        runnerUrl: `http://localhost:${runtime.containerServer.port}`,
-        projectRunnerUrls,
-        wsPort,
-        debug: isDebug(),
-        rpcTimeout: maxTestTimeoutForRpc
-    };
-    const browserProviderProjects = browserProjects.map((project)=>({
-            rootPath: normalize(project.rootPath),
-            provider: project.normalizedConfig.browser.provider
-        }));
-    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 dispatchBrowserRpcRequest = async ({ request, target })=>{
-        const timeoutFallbackMs = maxTestTimeoutForRpc;
-        const provider = resolveProviderForTestPath({
-            testPath: request.testPath,
-            browserProjects: browserProviderProjects
+    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
+            });
         });
-        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;
-        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');
+        _rpcPromiseMap.clear();
+        return handlerResults;
+    }
+    async function onMessage(data, ...extra) {
+        let msg;
         try {
-            return await implementation.dispatchRpc({
-                containerPage: runnerPage ? void 0 : activeContainerPage ?? void 0,
-                runnerPage,
-                request,
-                timeoutFallbackMs
-            });
-        } catch (error) {
-            if (error instanceof Error) throw error.message;
-            throw String(error);
+            msg = deserialize(data);
+        } catch (e) {
+            if (options.onGeneralError?.call(rpc, e) !== true) throw e;
+            return;
         }
-    };
-    runtime.dispatchHandlers.set(DISPATCH_NAMESPACE_BROWSER, async (dispatchRequest)=>{
-        const request = validateBrowserRpcRequest(dispatchRequest.args);
-        return dispatchBrowserRpcRequest({
-            request,
-            target: dispatchRequest.target
+        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;
+}
+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 createHeadedSerialTaskQueue = ()=>{
+    let queue = Promise.resolve();
+    const enqueue = (task)=>{
+        const next = queue.then(task);
+        queue = next.catch(()=>{});
+        return next;
+    };
+    return {
+        enqueue
+    };
+};
+const getFileTaskId = (testPath)=>`file:${testPath}`;
+const toError = (error)=>error instanceof Error ? error : new Error(String(error));
+const createDeferredPromise = ()=>{
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
     });
-    runtime.setContainerOptions(hostOptions);
-    const reporterResults = [];
-    const caseResults = [];
-    let fatalError = null;
-    const runnerSinks = new Map(browserProjects.map((project)=>[
-            project.name,
-            createRunnerEventSink(context, project.normalizedConfig)
+    return {
+        promise,
+        resolve,
+        reject
+    };
+};
+const claimHeadedCycleScope = (testPaths, currentTestFiles, pendingTestNamePatterns)=>{
+    const scope = [];
+    const filesByPath = new Map(currentTestFiles.map((file)=>[
+            file.testPath,
+            file
         ]));
-    const firstBrowserSink = runnerSinks.get(browserProjects[0].name);
-    const projectNameByTestPath = new Map();
-    const sinkForProjectName = (projectName)=>runnerSinks.get(projectName) ?? firstBrowserSink;
-    const sinkForTestPath = (testPath)=>{
-        const projectName = projectNameByTestPath.get(testPath);
-        return projectName ? sinkForProjectName(projectName) : firstBrowserSink;
+    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, isWatchMode, createDispatchRouter, handlers: { handleTestFileStart, handleTestCaseResult, handleTestFileComplete, handleLog, handleFatal }, fatalErrorRef, watchSignals, setDispatchPageResolver, createWatchSession, collectProjectEntries, logWatchReady, destroyRuntime })=>{
+    const { browser, browserLaunchOptions, watchState, wss } = runtime;
+    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 silentConsoleController = createSilentConsoleController({
-        runtimeConfig: {
-            silent: context.normalizedConfig.silent,
-            disableConsoleIntercept: context.normalizedConfig.disableConsoleIntercept
-        },
-        emitInterceptedLog: (log)=>sinkForTestPath(log.testPath).onConsoleLog(log),
-        writeOriginalLog: ()=>{}
-    });
-    const snapshotRpcMethods = {
-        async resolveSnapshotPath (testPath) {
-            return resolveSnapshotPathDefault(testPath, context.normalizedConfig.resolveSnapshotPath);
-        },
-        async readSnapshotFile (filepath) {
-            try {
-                return await promises.readFile(filepath, 'utf-8');
-            } catch  {
-                return null;
+    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}`));
+        });
+    }
+    setDispatchPageResolver(()=>({
+            containerPage
+        }));
+    const dispatchRouter = createDispatchRouter();
+    const headedReloadQueue = createHeadedSerialTaskQueue();
+    const pendingHeadedReloads = new Map();
+    let enqueueHeadedReload = async (_file, _testNamePattern)=>{
+        throw new Error('Headed reload queue is not initialized');
+    };
+    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 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;
+        }
+    };
+    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 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 (fatalErrorRef.current) 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 (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)=>{
+            const cycleScope = claimHeadedCycleScope(testPaths, currentTestFiles, pendingTestNamePatterns);
+            for (const { file, testNamePattern } of cycleScope)await enqueueHeadedReload(file, testNamePattern);
+        };
+        const refreshHostConfig = async ()=>{
+            const refreshedHostOptions = {
+                ...hostOptions,
+                snapshot: {
+                    updateSnapshot: context.snapshotManager.options.updateSnapshot
+                }
+            };
+            runtime.setContainerOptions(refreshedHostOptions);
+            await rpcManager.updateHostConfig(refreshedHostOptions);
+        };
+        watchSignals.setDispatchRerun(async ()=>{
+            const [, newProjectEntries] = await Promise.all([
+                refreshHostConfig(),
+                collectProjectEntries()
+            ]);
+            const rerunPlan = planWatchRerun({
+                projectEntries: newProjectEntries,
+                previousTestFiles: watchState.lastTestFiles,
+                affectedTestFiles: drainPendingAffectedTestFiles(watchState)
+            });
+            if (rerunPlan.filesChanged) {
+                const deletedTestPaths = collectDeletedTestPaths(watchState.lastTestFiles, rerunPlan.currentTestFiles);
+                if (deletedTestPaths.length > 0) context.updateReporterResultState([], [], deletedTestPaths);
+                watchState.lastTestFiles = rerunPlan.currentTestFiles;
+                currentTestFiles = rerunPlan.currentTestFiles;
+                await rpcManager.notifyTestFileUpdate(currentTestFiles);
+                if (0 === currentTestFiles.length) {
+                    logger.log(color.cyan('No browser test files remain after update.\n'));
+                    logWatchReady();
+                    return;
+                }
+                await waitForRunnerFramesReady(currentTestFiles.map((file)=>file.testPath));
+            }
+            if (rerunPlan.normalizedAffectedTestFiles.length > 0) {
+                logger.log(color.cyan(`Re-running ${rerunPlan.normalizedAffectedTestFiles.length} affected test file(s)...\n`));
+                await watchSignals.signalInvalidation(rerunPlan.normalizedAffectedTestFiles);
+                return;
+            }
+            if (!rerunPlan.filesChanged) logger.log(color.cyan('Tests will be re-executed automatically\n'));
+            logWatchReady();
+        });
+        runUiRequestedRerun = async (file, testNamePattern)=>{
+            await refreshHostConfig();
+            await watchSignals.signalInvalidation([
+                file.testPath
+            ], ()=>{
+                if (void 0 === testNamePattern) pendingTestNamePatterns.delete(normalize(file.testPath));
+                else pendingTestNamePatterns.set(normalize(file.testPath), testNamePattern);
+            });
+            await watchSignals.awaitSignalledCycle();
+        };
+        watchSession = createWatchSession(runScope);
+    }
+    const closeContainerRuntime = isWatchMode ? void 0 : async ()=>{
+        try {
+            await containerPage.close();
+        } catch  {}
+        try {
+            await containerContext.close();
+        } catch  {}
+        await destroyRuntime();
+    };
+    return {
+        testTime,
+        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, allTestFiles, projectRuntimeConfigs, hostOptions, watchState, isWatchMode, createDispatchRouter, handlers: { handleFatal, handleTestFileComplete }, watchSignals, setDispatchPageResolver, createWatchSession, collectProjectEntries, logWatchReady, destroyRuntime })=>{
+    const viewportByProject = mapViewportByProject(projectRuntimeConfigs);
+    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)));
             }
-        },
-        async saveSnapshotFile (filepath, content) {
-            const dir = dirname(filepath);
-            await promises.mkdir(dir, {
-                recursive: true
-            });
-            await promises.writeFile(filepath, content, 'utf-8');
-        },
-        async removeSnapshotFile (filepath) {
-            try {
-                await promises.unlink(filepath);
-            } catch  {}
+        });
+    };
+    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 handleTestFileStart = async (payload)=>{
-        projectNameByTestPath.set(payload.testPath, payload.projectName);
-        if (phaseTrackers) {
-            const tracker = new PhaseTracker({
-                trace: {
-                    testPath: payload.testPath,
-                    project: payload.projectName
+    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);
+                    }
                 },
-                pid: nextBrowserFilePid++
+                onDispatchRpc: async (request)=>dispatchRouter.dispatch({
+                        ...request,
+                        runToken: run.token,
+                        target: {
+                            sessionId: session.id,
+                            testFile: file.testPath,
+                            projectName: file.projectName,
+                            ...request.target
+                        }
+                    })
             });
-            tracker.transition('prepare');
-            phaseTrackers.set(payload.testPath, tracker);
+            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 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{
+            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();
         }
-        await sinkForProjectName(payload.projectName).onTestFileStart({
-            testId: getFileTaskId(payload.testPath),
-            testPath: payload.testPath,
-            tests: []
-        });
-    };
-    const handleTestFileReady = async (payload)=>{
-        phaseTrackers?.get(payload.testPath)?.transition('tests');
-        await sinkForTestPath(payload.testPath).onTestFileReady(payload);
-    };
-    const handleTestSuiteStart = async (payload)=>{
-        phaseTrackers?.get(payload.testPath)?.recordSuiteStart(payload);
-        await sinkForTestPath(payload.testPath).onTestSuiteStart(payload);
     };
-    const handleTestSuiteResult = async (payload)=>{
-        phaseTrackers?.get(payload.testPath)?.recordSuiteResult(payload);
-        await sinkForTestPath(payload.testPath).onTestSuiteResult(payload);
-        if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
-            taskId: payload.testId,
-            status: payload.status,
-            taskParentNames: payload.parentNames,
-            taskType: 'suite',
-            testPath: payload.testPath
+    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 handleTestCaseStart = async (payload)=>{
-        phaseTrackers?.get(payload.testPath)?.recordCaseStart(payload);
-        sinkForTestPath(payload.testPath).onTestCaseStart(payload);
-    };
-    const handleTestCaseResult = async (payload)=>{
-        caseResults.push(payload);
-        phaseTrackers?.get(payload.testPath)?.recordCaseResult(payload);
-        await sinkForTestPath(payload.testPath).onTestCaseResult(payload);
-        if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
-            taskId: payload.testId,
-            status: payload.status,
-            taskParentNames: payload.parentNames,
-            taskType: 'case',
-            testPath: payload.testPath
+    const testStart = Date.now();
+    await runFilesWithPool(allTestFiles);
+    const testTime = Date.now() - testStart;
+    let watchSession;
+    if (isWatchMode) {
+        const runScope = async (testPaths)=>{
+            const pathSet = new Set(testPaths.map((testPath)=>normalize(testPath)));
+            await runFilesWithPool(watchState.lastTestFiles.filter((file)=>pathSet.has(file.testPath)));
+        };
+        watchSignals.setInterrupt(async ()=>{
+            const active = runLifecycle.activeSession;
+            if (!active || active.cancelled) return;
+            runLifecycle.invalidateActiveToken();
+            await runLifecycle.cancel(active, {
+                waitForDone: false
+            });
         });
-    };
-    const handleTestFileComplete = async (payload)=>{
-        reporterResults.push(payload);
-        context.updateReporterResultState([
-            payload
-        ], payload.results);
-        if (phaseTrackers) {
-            const tracker = phaseTrackers.get(payload.testPath);
-            if (tracker) {
-                tracker.end();
-                const events = tracker.getTraceEvents();
-                if (events) onTraceEvents?.(events);
-                phaseTrackers.delete(payload.testPath);
+        watchSignals.setDispatchRerun(async ()=>{
+            const newProjectEntries = await collectProjectEntries();
+            const rerunPlan = planWatchRerun({
+                projectEntries: newProjectEntries,
+                previousTestFiles: watchState.lastTestFiles,
+                affectedTestFiles: drainPendingAffectedTestFiles(watchState)
+            });
+            if (rerunPlan.filesChanged) {
+                const deletedTestPaths = collectDeletedTestPaths(watchState.lastTestFiles, rerunPlan.currentTestFiles);
+                if (deletedTestPaths.length > 0) context.updateReporterResultState([], [], deletedTestPaths);
+                watchState.lastTestFiles = rerunPlan.currentTestFiles;
+                if (0 === rerunPlan.currentTestFiles.length) {
+                    logger.log(color.cyan('No browser test files remain after update.\n'));
+                    await watchSignals.signalInvalidation([]);
+                    return;
+                }
+                logger.log(color.cyan(`Test file set changed, re-running ${rerunPlan.currentTestFiles.length} file(s)...\n`));
+                await watchSignals.signalInvalidation([
+                    ...new Set(rerunPlan.currentTestFiles.map((file)=>file.testPath))
+                ]);
+                return;
             }
-        }
-        if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
-            taskId: payload.testId,
-            status: payload.status,
-            taskParentNames: payload.parentNames,
-            taskType: 'file',
-            testPath: payload.testPath
+            if (0 === rerunPlan.affectedTestFiles.length) {
+                logger.log(color.cyan('No affected browser test files detected, skipping re-run.\n'));
+                logWatchReady();
+                return;
+            }
+            logger.log(color.cyan(`Re-running ${rerunPlan.affectedTestFiles.length} affected test file(s)...\n`));
+            await watchSignals.signalInvalidation([
+                ...new Set(rerunPlan.affectedTestFiles.map((file)=>file.testPath))
+            ]);
         });
-        await sinkForTestPath(payload.testPath).onTestFileResult(payload);
-        if (isWatchMode && 'fail' === payload.status) ensureProcessExitCode(1);
+        watchSession = createWatchSession(runScope);
+    }
+    const closeHeadlessRuntime = isWatchMode ? void 0 : async ()=>{
+        sessionRegistry.clear();
+        await destroyRuntime();
+    };
+    return {
+        testTime,
+        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'),
+        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 normalizeJavaScriptUrl = (value, options)=>{
+    try {
+        const url = options?.origin ? new URL(value, options.origin) : new URL(value);
+        if ('http:' !== url.protocol && 'https:' !== url.protocol) return null;
+        url.search = '';
+        url.hash = '';
+        return url.toString();
+    } catch  {
+        return null;
+    }
+};
+const resolveInlineSourceMap = (code)=>{
+    const converter = convert_source_map.fromSource(code);
+    if (!converter) return null;
+    return converter.toObject();
+};
+const fetchSourceMap = async (jsUrl, fetcher)=>{
+    const jsResponse = await fetcher(jsUrl);
+    if (!jsResponse.ok) return null;
+    const code = await jsResponse.text();
+    const inlineMap = resolveInlineSourceMap(code);
+    if (inlineMap) return inlineMap;
+    const mapResponse = await fetcher(`${jsUrl}.map`);
+    if (!mapResponse.ok) return null;
+    return await mapResponse.json();
+};
+const loadSourceMapWithCache = async ({ jsUrl, cache, force = false, origin, fetcher = fetch })=>{
+    const normalizedUrl = normalizeJavaScriptUrl(jsUrl, {
+        origin
+    });
+    if (!normalizedUrl) return null;
+    if (!force && cache.has(normalizedUrl)) return cache.get(normalizedUrl) ?? null;
+    try {
+        const sourceMap = await fetchSourceMap(normalizedUrl, fetcher);
+        cache.set(normalizedUrl, sourceMap);
+        return sourceMap;
+    } catch  {
+        cache.set(normalizedUrl, null);
+        return null;
+    }
+};
+const watchContext = {
+    runtime: null,
+    cleanupRegistered: false,
+    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?.();
+            signalledCycle = Promise.resolve(onInvalidate?.({
+                isFirstBuild: false,
+                fileFilters
+            })).catch((error)=>{
+                logger.error(color.red('Browser Mode watch cycle failed:'), error);
+            });
+        },
+        async awaitSignalledCycle () {
+            await signalledCycle;
+        }
     };
-    const handleLog = async (payload)=>{
-        const log = {
-            content: payload.content,
-            name: getPrettyConsoleName(payload.level),
-            taskId: payload.taskId,
-            taskName: payload.taskName,
-            taskParentNames: payload.taskParentNames,
-            taskType: payload.taskType,
-            testPath: payload.testPath,
-            type: payload.type,
-            trace: payload.trace
+};
+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 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
+            })
         };
-        silentConsoleController.onConsoleLog(log);
     };
-    const handleFatal = async (payload)=>{
-        const error = new Error(payload.message);
-        error.stack = payload.stack;
-        fatalError = error;
-        if (isWatchMode) ensureProcessExitCode(1);
+    const getBrowserSourcemap = async (sourcePath)=>{
+        const result = await resolveBrowserSourcemap(sourcePath);
+        return result.handled ? result.sourcemap : null;
     };
-    const runSnapshotRpc = async (request)=>{
-        switch(request.method){
-            case 'resolveSnapshotPath':
-                return snapshotRpcMethods.resolveSnapshotPath(request.args.testPath);
-            case 'readSnapshotFile':
-                return snapshotRpcMethods.readSnapshotFile(request.args.filepath);
-            case 'saveSnapshotFile':
-                return snapshotRpcMethods.saveSnapshotFile(request.args.filepath, request.args.content);
-            case 'removeSnapshotFile':
-                return snapshotRpcMethods.removeSnapshotFile(request.args.filepath);
-            default:
-                {
-                    const _exhaustive = request;
-                    return _exhaustive;
-                }
+    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 createDispatchRouter = (options)=>createHostDispatchRouter({
-            routerOptions: options,
-            runnerCallbacks: {
-                onTestFileStart: handleTestFileStart,
-                onTestFileReady: handleTestFileReady,
-                onTestSuiteStart: handleTestSuiteStart,
-                onTestSuiteResult: handleTestSuiteResult,
-                onTestCaseStart: handleTestCaseStart,
-                onTestCaseResult: handleTestCaseResult,
-                onTestFileComplete: handleTestFileComplete,
-                onLog: handleLog,
-                onFatal: handleFatal
+    const coverageConfig = browserProjects.find((project)=>project.normalizedConfig.coverage?.enabled)?.normalizedConfig.coverage;
+    const coverageProvider = coverageConfig?.enabled ? await createCoverageProvider(coverageConfig, context.rootPath) : null;
+    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
             },
-            runSnapshotRpc,
-            extensionHandlers: runtime.dispatchHandlers,
-            onDuplicateNamespace: (namespace)=>{
-                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)));
-                }
-            });
+            hasFailure: false,
+            getSourcemap: getBrowserSourcemap,
+            resolveSourcemap: resolveBrowserSourcemap
         };
-        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 writeEmptyLaunchExitCode = ()=>{
+        process.exitCode = resolveEmptyLaunchExitCode(process.exitCode, {
+            allowEmptyRun,
+            isWatchMode,
+            passWithNoTests: context.normalizedConfig.passWithNoTests
         });
-        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;
+    };
+    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;
+    const watchSignals = createWatchSignals(onInvalidate);
+    if (!runtime) {
+        try {
+            runtime = await createBrowserRuntime({
+                context,
+                projectEntries,
+                browserProjects,
+                shardedEntries: options?.shardedEntries,
+                freezeShardedEntries: options?.freezeShardedEntries,
+                tempDir,
+                isWatchMode,
+                onTriggerRerun: isWatchMode ? async ()=>{
+                    await watchSignals.runDispatchRerun();
+                } : void 0,
+                containerDistPath,
+                containerDevServer,
+                skipProviderLaunch: filesOnly,
+                appliedModifyRstestConfigEnvironments: options?.appliedModifyRstestConfigEnvironments
             });
-            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: []
+        } catch (error) {
+            return failWithError(error, async ()=>{
+                await promises.rm(tempDir, {
+                    recursive: true,
+                    force: true
+                }).catch(()=>{});
             });
-        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);
+        }
+        if (isWatchMode && !filesOnly) {
+            watchContext.runtime = runtime;
+            registerWatchCleanup(context.embedded);
+        }
+    }
+    const watchState = runtime.watchState;
+    if (isWatchMode) watchState.lastTestFiles = collectWatchTestFiles(projectEntries);
+    const seedPendingRerun = (testPaths)=>{
+        const wanted = testPaths ? new Set(testPaths.map((testPath)=>normalize(testPath))) : null;
+        let seeded = 0;
+        for (const file of watchState.lastTestFiles){
+            if (wanted && !wanted.has(file.testPath)) continue;
+            const pending = watchState.pendingAffectedTestFiles.get(file.projectName) ?? new Set();
+            pending.add(file.testPath);
+            watchState.pendingAffectedTestFiles.set(file.projectName, pending);
+            seeded += 1;
+        }
+        return seeded;
+    };
+    const buildRerunOutcome = ({ rerunTestPaths, testTime, unhandledErrors })=>{
+        const rerunPathSet = new Set(rerunTestPaths);
+        const rerunResults = context.reporterResults.results.filter((result)=>rerunPathSet.has(result.testPath));
+        const coverageMap = buildBrowserCoverageMap(rerunResults, coverageProvider);
+        return {
+            results: rerunResults,
+            testResults: context.reporterResults.testResults.filter((result)=>rerunPathSet.has(result.testPath)),
+            errors: unhandledErrors ?? [],
+            testPaths: rerunTestPaths,
+            duration: {
+                buildTime: drainPendingBuildTime(watchState),
+                testTime
             },
-            runFiles: async (files)=>{
-                prepareWatchRerunState(context);
-                await notifyTestRunStart();
+            coverage: coverageMap?.files().length ? {
+                map: coverageMap.toJSON()
+            } : void 0,
+            resolveSourcemap: resolveBrowserSourcemap
+        };
+    };
+    const createWatchSession = (execute)=>({
+            runCycle: async (testPaths)=>{
                 const rerunStartTime = Date.now();
-                const fatalErrorBeforeRun = fatalError;
+                const fatalErrorBeforeRun = fatalErrorRef.current;
                 let rerunError;
                 try {
-                    await runFilesWithPool(files);
+                    await execute(testPaths);
                 } 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
+                const rerunFatalError = fatalErrorRef.current && fatalErrorRef.current !== fatalErrorBeforeRun ? fatalErrorRef.current : void 0;
+                return buildRerunOutcome({
+                    rerunTestPaths: testPaths,
+                    testTime: Math.max(0, Date.now() - rerunStartTime),
+                    unhandledErrors: rerunError ? [
+                        rerunError
+                    ] : rerunFatalError ? [
+                        rerunFatalError
+                    ] : void 0
                 });
             },
-            onInterrupt: (run)=>{
-                logger.debug(`[Headless] Interrupting active run token ${run.token} before scheduling latest rerun`);
+            requestRerun: async (testPaths)=>{
+                const seeded = seedPendingRerun(testPaths);
+                if (testPaths && 0 === seeded) return;
+                await watchSignals.runDispatchRerun();
+                await watchSignals.awaitSignalledCycle();
             }
         });
-        awaitHeadlessRerunIdle = ()=>latestRerunScheduler.whenIdle();
-        if (0 === allTestFiles.length) {
-            const duration = {
-                totalTime: buildTime,
-                buildTime,
-                testTime: 0
-            };
-            const result = {
-                results: reporterResults,
-                testResults: caseResults,
-                duration,
-                hasFailure: false,
-                getSourcemap: getBrowserSourcemap,
-                resolveSourcemap: resolveBrowserSourcemap,
-                close: isWatchMode ? void 0 : async ()=>{
-                    sessionRegistry.clear();
-                    await destroyBrowserRuntime(runtime);
-                },
-                watch: watchHandles
-            };
-            if (isWatchMode) await notifyTestRunEnd({
-                duration
-            });
-            if (isWatchMode) {
-                triggerRerun = async ()=>{
-                    const newProjectEntries = await collectProjectEntries(context);
-                    const rerunPlan = planWatchRerun({
-                        projectEntries: newProjectEntries,
-                        previousTestFiles: watchState.lastTestFiles,
-                        affectedTestFiles: drainPendingAffectedTestFiles(watchState)
-                    });
-                    if (rerunPlan.filesChanged) {
-                        watchState.lastTestFiles = rerunPlan.currentTestFiles;
-                        if (0 === rerunPlan.currentTestFiles.length) {
-                            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;
-                    }
-                    logWatchReadyMessage(context, enableCliShortcuts);
-                };
-                watchState.hooksEnabled = true;
-                logWatchReadyMessage(context, enableCliShortcuts);
-            }
-            return result;
-        }
-        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,
+    projectEntries = runtime.projectEntries;
+    totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
+    const buildTime = Date.now() - buildStart;
+    if (filesOnly) return {
+        results: [],
+        testResults: [],
+        duration: {
+            totalTime: buildTime,
             buildTime,
-            testTime
-        };
-        context.updateReporterResultState(reporterResults, caseResults);
-        const isFailure = reporterResults.some((result)=>'fail' === result.status);
-        if (isWatchMode && isFailure) ensureProcessExitCode(1);
-        const result = {
-            results: reporterResults,
-            testResults: caseResults,
-            duration,
-            hasFailure: isFailure,
-            getSourcemap: getBrowserSourcemap,
-            resolveSourcemap: resolveBrowserSourcemap,
-            close: closeHeadlessRuntime,
-            watch: watchHandles
-        };
-        if (isWatchMode) try {
-            await notifyTestRunEnd({
-                duration
-            });
-        } 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();
+            testTime: 0
+        },
+        hasFailure: false,
+        getSourcemap: getBrowserSourcemap,
+        resolveSourcemap: resolveBrowserSourcemap,
+        close: ()=>destroyBrowserRuntime(runtime)
     };
-    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();
-        });
+    if (0 === totalTests) {
+        writeEmptyLaunchExitCode();
+        await destroyBrowserRuntime(runtime);
+        return allowEmptyRun ? createEmptyRunResult() : void 0;
+    }
+    const { browser, browserLaunchOptions, wsPort } = runtime;
+    const allTestFiles = projectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
+                testPath: normalize(testPath),
+                projectName: entry.project.name
+            })));
+    const projectRuntimeConfigs = browserProjects.map((project)=>({
+            name: project.name,
+            environmentName: project.environmentName,
+            projectRoot: normalize(project.rootPath),
+            runtimeConfig: serializableConfig(projectRuntimeConfig(project, {
+                envMode: 'static',
+                envOverlay: env
+            })),
+            viewport: project.normalizedConfig.browser.viewport
+        }));
+    const maxTestTimeoutForRpc = getMaxTestTimeoutForRpc(browserProjects);
+    const projectRunnerUrls = Object.fromEntries([
+        ...runtime.projectServers
+    ].map(([name, server])=>[
+            name,
+            `http://localhost:${server.port}`
+        ]));
+    const hostOptions = {
+        rootPath: normalize(context.rootPath),
+        projects: projectRuntimeConfigs,
+        snapshot: {
+            updateSnapshot: options?.updateSnapshot ?? context.snapshotManager.options.updateSnapshot
+        },
+        runnerUrl: `http://localhost:${runtime.containerServer.port}`,
+        projectRunnerUrls,
+        wsPort,
+        debug: isDebug(),
+        rpcTimeout: maxTestTimeoutForRpc
     };
-    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;
+    const browserProviderProjects = browserProjects.map((project)=>({
+            rootPath: normalize(project.rootPath),
+            provider: project.normalizedConfig.browser.provider
+        }));
+    const implementationByProvider = new Map();
+    for (const browserProject of browserProviderProjects)if (!implementationByProvider.has(browserProject.provider)) implementationByProvider.set(browserProject.provider, getBrowserProviderImplementation(browserProject.provider));
+    let resolveDispatchPages = ()=>({});
+    const setDispatchPageResolver = (resolver)=>{
+        resolveDispatchPages = resolver;
     };
-    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(()=>{});
+    const dispatchBrowserRpcRequest = async ({ request, target })=>{
+        const timeoutFallbackMs = maxTestTimeoutForRpc;
+        const provider = resolveProviderForTestPath({
+            testPath: request.testPath,
+            browserProjects: browserProviderProjects
         });
-        if (isWatchMode) {
-            runtime.containerPage = containerPage;
-            runtime.containerContext = containerContext;
+        const implementation = implementationByProvider.get(provider);
+        if (!implementation) throw new Error(`Browser provider implementation not found: ${provider}`);
+        const { runnerPage, containerPage } = resolveDispatchPages(target);
+        if (target?.sessionId && !runnerPage) throw new Error(`Runner page session not found for browser dispatch: ${target.sessionId}`);
+        if (!runnerPage && !containerPage) throw new Error('Browser container page is not initialized');
+        try {
+            return await implementation.dispatchRpc({
+                containerPage: runnerPage ? void 0 : containerPage,
+                runnerPage,
+                request,
+                timeoutFallbackMs
+            });
+        } catch (error) {
+            if (error instanceof Error) throw error.message;
+            throw String(error);
         }
-        containerPage.on('console', (msg)=>{
-            const text = msg.text();
-            if (text.startsWith('[Container]') || text.startsWith('[Runner]')) logger.log(color.gray(`[Browser Console] ${text}`));
+    };
+    runtime.dispatchHandlers.set(DISPATCH_NAMESPACE_BROWSER, async (dispatchRequest)=>{
+        const request = validateBrowserRpcRequest(dispatchRequest.args);
+        return dispatchBrowserRpcRequest({
+            request,
+            target: dispatchRequest.target
         });
-    }
-    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');
+    });
+    runtime.setContainerOptions(hostOptions);
+    const reporterResults = [];
+    const caseResults = [];
+    const fatalErrorRef = {
+        current: null
     };
-    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 runnerSinks = new Map(browserProjects.map((project)=>[
+            project.name,
+            createRunnerEventSink(context, project.normalizedConfig)
+        ]));
+    const sinkForProjectName = (projectName)=>{
+        const sink = runnerSinks.get(projectName);
+        if (!sink) throw new Error(`No runner event sink for project "${projectName}"`);
+        return sink;
     };
-    const rejectAllPendingHeadedReloads = (error)=>{
-        for (const [testPath, pending] of pendingHeadedReloads){
-            pendingHeadedReloads.delete(testPath);
-            pending.deferred.reject(error);
+    const silentConsoleController = createSilentConsoleController({
+        runtimeConfig: {
+            silent: context.normalizedConfig.silent,
+            disableConsoleIntercept: context.normalizedConfig.disableConsoleIntercept
+        },
+        emitInterceptedLog: (log)=>sinkForProjectName(log.project).onConsoleLog(log),
+        writeOriginalLog: ()=>{}
+    });
+    const snapshotRpcMethods = {
+        async resolveSnapshotPath (testPath) {
+            return resolveSnapshotPathDefault(testPath, context.normalizedConfig.resolveSnapshotPath);
+        },
+        async readSnapshotFile (filepath) {
+            try {
+                return await promises.readFile(filepath, 'utf-8');
+            } catch  {
+                return null;
+            }
+        },
+        async saveSnapshotFile (filepath, content) {
+            const dir = dirname(filepath);
+            await promises.mkdir(dir, {
+                recursive: true
+            });
+            await promises.writeFile(filepath, content, 'utf-8');
+        },
+        async removeSnapshotFile (filepath) {
+            try {
+                await promises.unlink(filepath);
+            } catch  {}
         }
     };
-    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 handleTestFileStart = async (payload)=>{
+        if (phaseTrackers) {
+            const tracker = new PhaseTracker({
+                trace: {
+                    testPath: payload.testPath,
+                    project: payload.projectName
+                },
+                pid: nextBrowserFilePid++
+            });
+            tracker.transition('prepare');
+            phaseTrackers.set(trackerKey(payload.projectName, payload.testPath), tracker);
         }
-        const deferred = createDeferredPromise();
-        pendingHeadedReloads.set(testPath, {
-            runId,
-            deferred
+        await sinkForProjectName(payload.projectName).onTestFileStart({
+            testId: getFileTaskId(payload.testPath),
+            testPath: payload.testPath,
+            project: payload.projectName,
+            tests: []
         });
-        return deferred.promise;
     };
-    const resolvePendingHeadedReload = (testPath, runId)=>{
-        const pending = pendingHeadedReloads.get(testPath);
-        if (!pending) return;
-        if (runId && pending.runId !== runId) return void logger.debug(`[Browser UI] Ignoring stale file-complete for ${testPath}. current=${pending.runId}, incoming=${runId}`);
-        pendingHeadedReloads.delete(testPath);
-        pending.deferred.resolve();
+    const handleTestFileReady = async (payload)=>{
+        phaseTrackers?.get(trackerKey(payload.project, payload.testPath))?.transition('tests');
+        await sinkForProjectName(payload.project).onTestFileReady(payload);
     };
-    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 handleTestSuiteStart = async (payload)=>{
+        phaseTrackers?.get(trackerKey(payload.project, payload.testPath))?.recordSuiteStart(payload);
+        await sinkForProjectName(payload.project).onTestSuiteStart(payload);
     };
-    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'
+    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({
+            taskId: payload.testId,
+            status: payload.status,
+            taskParentNames: payload.parentNames,
+            taskType: 'suite',
+            testPath: payload.testPath
         });
-        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);
+    };
+    const handleTestCaseStart = async (payload)=>{
+        phaseTrackers?.get(trackerKey(payload.project, payload.testPath))?.recordCaseStart(payload);
+        sinkForProjectName(payload.project).onTestCaseStart(payload);
+    };
+    const handleTestCaseResult = async (payload)=>{
+        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({
+            taskId: payload.testId,
+            status: payload.status,
+            taskParentNames: payload.parentNames,
+            taskType: 'case',
+            testPath: payload.testPath
         });
-    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;
+    };
+    const handleTestFileComplete = async (payload)=>{
+        reporterResults.push(payload);
+        context.updateReporterResultState([
+            payload
+        ], payload.results);
+        if (phaseTrackers) {
+            const key = trackerKey(payload.project, payload.testPath);
+            const tracker = phaseTrackers.get(key);
+            if (tracker) {
+                tracker.end();
+                const events = tracker.getTraceEvents();
+                if (events) onTraceEvents?.(events);
+                phaseTrackers.delete(key);
             }
-        } catch (error) {
-            fatalError = fatalError ?? toError(error);
-            if (isWatchMode) ensureProcessExitCode(1);
         }
-        testTime = Date.now() - testStart;
-    }
-    if (isWatchMode) triggerRerun = async ()=>{
-        const refreshedHostOptions = {
-            ...hostOptions,
-            snapshot: {
-                updateSnapshot: context.snapshotManager.options.updateSnapshot
-            }
-        };
-        runtime.setContainerOptions(refreshedHostOptions);
-        const [, newProjectEntries] = await Promise.all([
-            rpcManager.updateHostConfig(refreshedHostOptions),
-            collectProjectEntries(context)
-        ]);
-        const rerunPlan = planWatchRerun({
-            projectEntries: newProjectEntries,
-            previousTestFiles: watchState.lastTestFiles,
-            affectedTestFiles: drainPendingAffectedTestFiles(watchState)
+        if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
+            taskId: payload.testId,
+            status: payload.status,
+            taskParentNames: payload.parentNames,
+            taskType: 'file',
+            testPath: payload.testPath
         });
-        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);
-        }
+        await sinkForProjectName(payload.project).onTestFileResult(payload);
     };
-    const closeContainerRuntime = isWatchMode ? void 0 : async ()=>{
-        try {
-            await containerPage.close();
-        } catch  {}
-        try {
-            await containerContext.close();
-        } catch  {}
-        await destroyBrowserRuntime(runtime);
+    const handleLog = async (payload)=>{
+        const log = {
+            content: payload.content,
+            name: getPrettyConsoleName(payload.level),
+            taskId: payload.taskId,
+            taskName: payload.taskName,
+            taskParentNames: payload.taskParentNames,
+            taskType: payload.taskType,
+            testPath: payload.testPath,
+            project: payload.projectName,
+            type: payload.type,
+            trace: payload.trace
+        };
+        silentConsoleController.onConsoleLog(log);
+    };
+    const handleFatal = async (payload)=>{
+        const error = new Error(payload.message);
+        error.stack = payload.stack;
+        fatalErrorRef.current = error;
+    };
+    const runSnapshotRpc = async (request)=>{
+        switch(request.method){
+            case 'resolveSnapshotPath':
+                return snapshotRpcMethods.resolveSnapshotPath(request.args.testPath);
+            case 'readSnapshotFile':
+                return snapshotRpcMethods.readSnapshotFile(request.args.filepath);
+            case 'saveSnapshotFile':
+                return snapshotRpcMethods.saveSnapshotFile(request.args.filepath, request.args.content);
+            case 'removeSnapshotFile':
+                return snapshotRpcMethods.removeSnapshotFile(request.args.filepath);
+            default:
+                {
+                    const _exhaustive = request;
+                    return _exhaustive;
+                }
+        }
     };
-    if (fatalError) return failWithError(fatalError, closeContainerRuntime);
-    const duration = {
-        totalTime: buildTime + testTime,
-        buildTime,
-        testTime
+    const createDispatchRouter = (options)=>createHostDispatchRouter({
+            routerOptions: options,
+            runnerCallbacks: {
+                onTestFileStart: handleTestFileStart,
+                onTestFileReady: handleTestFileReady,
+                onTestSuiteStart: handleTestSuiteStart,
+                onTestSuiteResult: handleTestSuiteResult,
+                onTestCaseStart: handleTestCaseStart,
+                onTestCaseResult: handleTestCaseResult,
+                onTestFileComplete: handleTestFileComplete,
+                onLog: handleLog,
+                onFatal: handleFatal
+            },
+            runSnapshotRpc,
+            extensionHandlers: runtime.dispatchHandlers,
+            onDuplicateNamespace: (namespace)=>{
+                logger.debug(`[Dispatch] Skip registering dispatch namespace "${namespace}" because it is already reserved`);
+            }
+        });
+    const schedulerDeps = {
+        context,
+        allTestFiles,
+        hostOptions,
+        isWatchMode,
+        createDispatchRouter,
+        fatalErrorRef,
+        watchSignals,
+        setDispatchPageResolver,
+        createWatchSession,
+        collectProjectEntries: ()=>browserRsbuild_collectProjectEntries(context),
+        logWatchReady: ()=>logWatchReadyMessage(context, enableCliShortcuts),
+        destroyRuntime: ()=>destroyBrowserRuntime(runtime)
     };
+    const { testTime, watchSession, close } = useHeadlessDirect ? await createHeadlessScheduler({
+        ...schedulerDeps,
+        browser,
+        browserLaunchOptions,
+        projectServers: runtime.projectServers,
+        projectRuntimeConfigs,
+        watchState,
+        handlers: {
+            handleFatal,
+            handleTestFileComplete
+        }
+    }) : await createHeadedScheduler({
+        ...schedulerDeps,
+        runtime,
+        handlers: {
+            handleTestFileStart,
+            handleTestCaseResult,
+            handleTestFileComplete,
+            handleLog,
+            handleFatal
+        }
+    });
+    if (fatalErrorRef.current) return failWithError(fatalErrorRef.current, close);
     context.updateReporterResultState(reporterResults, caseResults);
-    const isFailure = reporterResults.some((result)=>'fail' === result.status);
-    if (isWatchMode && isFailure) ensureProcessExitCode(1);
-    const result = {
+    watchState.hooksEnabled = isWatchMode;
+    return {
         results: reporterResults,
         testResults: caseResults,
-        duration,
-        hasFailure: isFailure,
+        duration: {
+            totalTime: buildTime + testTime,
+            buildTime,
+            testTime
+        },
+        hasFailure: reporterResults.some((result)=>'fail' === result.status),
         getSourcemap: getBrowserSourcemap,
         resolveSourcemap: resolveBrowserSourcemap,
-        close: closeContainerRuntime,
-        watch: watchHandles
+        close,
+        watchSession
     };
-    if (isWatchMode) try {
-        await notifyTestRunEnd({
-            duration
-        });
-    } 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);
@@ -5164,7 +5078,8 @@ 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
         }));
@@ -5297,8 +5212,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);
@@ -5322,6 +5240,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,
@@ -5330,24 +5257,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 {
@@ -5362,6 +5302,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?.();