@rstest/browser 0.8.5 → 0.9.1

package/dist/index.js

@@ -7,6 +7,9 @@ import open_editor from "open-editor";
 import { basename, dirname, join, normalize, relative, resolve as external_pathe_resolve } from "pathe";
 import sirv from "sirv";
 import { WebSocketServer } from "ws";
+import node_os from "node:os";
+import convert_source_map from "convert-source-map";
+import { DISPATCH_RPC_BRIDGE_NAME, DISPATCH_MESSAGE_TYPE, DISPATCH_NAMESPACE_RUNNER } from "./361.js";
 __webpack_require__.add({
     "../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js" (module, __unused_rspack_exports, __webpack_require__) {
         const pico = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/lib/picomatch.js");
@@ -1610,6 +1613,959 @@ function createBirpc($functions, options) {
     _promiseInit = on(onMessage);
     return rpc;
 }
+const DEFAULT_MAX_HEADLESS_WORKERS = 12;
+const getNumCpus = ()=>node_os.availableParallelism?.() ?? node_os.cpus().length;
+const parseWorkers = (maxWorkers, numCpus = getNumCpus())=>{
+    const parsed = Number.parseInt(maxWorkers.toString(), 10);
+    if ('string' == typeof maxWorkers && maxWorkers.trim().endsWith('%')) {
+        const workers = Math.floor(parsed / 100 * numCpus);
+        return Math.max(workers, 1);
+    }
+    return parsed > 0 ? parsed : 1;
+};
+const resolveDefaultHeadlessWorkers = (command, numCpus = getNumCpus())=>{
+    const baseWorkers = Math.max(Math.min(DEFAULT_MAX_HEADLESS_WORKERS, numCpus - 1), 1);
+    return 'watch' === command ? Math.max(Math.floor(baseWorkers / 2), 1) : baseWorkers;
+};
+const getHeadlessConcurrency = (context, totalTests)=>{
+    if (totalTests <= 0) return 1;
+    const maxWorkers = context.normalizedConfig.pool.maxWorkers;
+    if (void 0 !== maxWorkers) return Math.min(parseWorkers(maxWorkers), totalTests);
+    return Math.min(resolveDefaultHeadlessWorkers(context.command), totalTests);
+};
+const toErrorMessage = (error)=>error instanceof Error ? error.message : String(error);
+class HostDispatchRouter {
+    handlers = new Map();
+    options;
+    constructor(options){
+        this.options = options ?? {};
+    }
+    register(namespace, handler) {
+        this.handlers.set(namespace, handler);
+    }
+    unregister(namespace) {
+        this.handlers.delete(namespace);
+    }
+    has(namespace) {
+        return this.handlers.has(namespace);
+    }
+    async dispatch(request) {
+        const runToken = request.runToken;
+        if ('number' == typeof runToken && this.options.isRunTokenStale?.(runToken)) {
+            this.options.onStale?.(request);
+            return {
+                requestId: request.requestId,
+                runToken,
+                stale: true
+            };
+        }
+        const handler = this.handlers.get(request.namespace);
+        if (!handler) return {
+            requestId: request.requestId,
+            runToken,
+            error: `No dispatch handler registered for namespace "${request.namespace}"`
+        };
+        try {
+            const result = await handler(request);
+            return {
+                requestId: request.requestId,
+                runToken,
+                result
+            };
+        } catch (error) {
+            return {
+                requestId: request.requestId,
+                runToken,
+                error: toErrorMessage(error)
+            };
+        }
+    }
+}
+const toSnapshotRpcRequest = (request)=>{
+    switch(request.method){
+        case 'resolveSnapshotPath':
+            return {
+                id: request.requestId,
+                method: 'resolveSnapshotPath',
+                args: request.args
+            };
+        case 'readSnapshotFile':
+            return {
+                id: request.requestId,
+                method: 'readSnapshotFile',
+                args: request.args
+            };
+        case 'saveSnapshotFile':
+            return {
+                id: request.requestId,
+                method: 'saveSnapshotFile',
+                args: request.args
+            };
+        case 'removeSnapshotFile':
+            return {
+                id: request.requestId,
+                method: 'removeSnapshotFile',
+                args: request.args
+            };
+        default:
+            return null;
+    }
+};
+const createHostDispatchRouter = ({ routerOptions, runnerCallbacks, runSnapshotRpc, extensionHandlers, onDuplicateNamespace })=>{
+    const router = new HostDispatchRouter(routerOptions);
+    router.register('runner', async (request)=>{
+        switch(request.method){
+            case 'file-start':
+                await runnerCallbacks.onTestFileStart(request.args);
+                break;
+            case 'file-ready':
+                await runnerCallbacks.onTestFileReady(request.args);
+                break;
+            case 'suite-start':
+                await runnerCallbacks.onTestSuiteStart(request.args);
+                break;
+            case 'suite-result':
+                await runnerCallbacks.onTestSuiteResult(request.args);
+                break;
+            case 'case-start':
+                await runnerCallbacks.onTestCaseStart(request.args);
+                break;
+            case 'case-result':
+                await runnerCallbacks.onTestCaseResult(request.args);
+                break;
+            case 'file-complete':
+                await runnerCallbacks.onTestFileComplete(request.args);
+                break;
+            case 'log':
+                await runnerCallbacks.onLog(request.args);
+                break;
+            case 'fatal':
+                await runnerCallbacks.onFatal(request.args);
+                break;
+            default:
+                break;
+        }
+    });
+    router.register('snapshot', async (request)=>{
+        const snapshotRequest = toSnapshotRpcRequest(request);
+        if (!snapshotRequest) return;
+        return runSnapshotRpc(snapshotRequest);
+    });
+    for (const [namespace, handler] of extensionHandlers ?? []){
+        if (router.has(namespace)) {
+            onDuplicateNamespace?.(namespace);
+            continue;
+        }
+        router.register(namespace, handler);
+    }
+    return router;
+};
+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',
+    'fill',
+    'hover',
+    'press',
+    'clear',
+    'check',
+    'uncheck',
+    'focus',
+    'blur',
+    'scrollIntoViewIfNeeded',
+    'waitFor',
+    'dispatchEvent',
+    'selectOption',
+    'setInputFiles'
+]);
+const supportedExpectElementMatchers = new Set([
+    'toBeVisible',
+    'toBeHidden',
+    'toBeEnabled',
+    'toBeDisabled',
+    'toBeAttached',
+    'toBeDetached',
+    'toBeEditable',
+    'toBeFocused',
+    'toBeEmpty',
+    'toBeInViewport',
+    'toHaveText',
+    'toContainText',
+    'toHaveValue',
+    'toHaveAttribute',
+    'toHaveClass',
+    'toHaveCount',
+    'toBeChecked',
+    'toBeUnchecked',
+    'toHaveId',
+    'toHaveCSS',
+    'toHaveJSProperty'
+]);
+const reviveBrowserLocatorText = (text)=>{
+    if ('string' === text.type) return text.value;
+    return new RegExp(text.source, text.flags);
+};
+const compilePlaywrightLocator = (frame, locatorIR)=>{
+    const compileFromFrame = (ir)=>{
+        let current = frame;
+        const ensureLocator = ()=>{
+            if (current.filter) return current;
+            current = current.locator(':root');
+            return current;
+        };
+        for (const step of ir.steps)switch(step.type){
+            case 'getByRole':
+                {
+                    const name = step.options?.name ? reviveBrowserLocatorText(step.options.name) : void 0;
+                    const options = step.options ? {
+                        ...step.options,
+                        name
+                    } : void 0;
+                    current = current.getByRole(step.role, options);
+                    break;
+                }
+            case 'locator':
+                current = current.locator(step.selector);
+                break;
+            case 'getByText':
+                current = current.getByText(reviveBrowserLocatorText(step.text), step.options);
+                break;
+            case 'getByLabel':
+                current = current.getByLabel(reviveBrowserLocatorText(step.text), step.options);
+                break;
+            case 'getByPlaceholder':
+                current = current.getByPlaceholder(reviveBrowserLocatorText(step.text), step.options);
+                break;
+            case 'getByAltText':
+                current = current.getByAltText(reviveBrowserLocatorText(step.text), step.options);
+                break;
+            case 'getByTitle':
+                current = current.getByTitle(reviveBrowserLocatorText(step.text), step.options);
+                break;
+            case 'getByTestId':
+                current = current.getByTestId(reviveBrowserLocatorText(step.text));
+                break;
+            case 'filter':
+                {
+                    const locator = ensureLocator();
+                    const options = {};
+                    if (step.options?.hasText) options.hasText = reviveBrowserLocatorText(step.options.hasText);
+                    if (step.options?.hasNotText) options.hasNotText = reviveBrowserLocatorText(step.options.hasNotText);
+                    if (step.options?.has) options.has = compileFromFrame(step.options.has);
+                    if (step.options?.hasNot) options.hasNot = compileFromFrame(step.options.hasNot);
+                    current = locator.filter(options);
+                    break;
+                }
+            case 'and':
+                {
+                    const locator = ensureLocator();
+                    const other = compileFromFrame(step.locator);
+                    current = locator.and(other);
+                    break;
+                }
+            case 'or':
+                {
+                    const locator = ensureLocator();
+                    const other = compileFromFrame(step.locator);
+                    current = locator.or(other);
+                    break;
+                }
+            case 'nth':
+                {
+                    const locator = ensureLocator();
+                    current = locator.nth(step.index);
+                    break;
+                }
+            case 'first':
+                {
+                    const locator = ensureLocator();
+                    current = locator.first();
+                    break;
+                }
+            case 'last':
+                {
+                    const locator = ensureLocator();
+                    current = locator.last();
+                    break;
+                }
+            default:
+                throw new Error(`Unknown locator step: ${String(step?.type)}`);
+        }
+        return ensureLocator();
+    };
+    return compileFromFrame(locatorIR);
+};
+const serializeExpectedText = (text, options)=>{
+    const base = {
+        matchSubstring: options?.matchSubstring,
+        ignoreCase: options?.ignoreCase,
+        normalizeWhiteSpace: options?.normalizeWhiteSpace
+    };
+    if ('string' === text.type) return [
+        {
+            ...base,
+            string: text.value
+        }
+    ];
+    return [
+        {
+            ...base,
+            regexSource: text.source,
+            regexFlags: text.flags
+        }
+    ];
+};
+const formatExpectError = (result)=>{
+    const parts = [];
+    if (result.errorMessage) parts.push(result.errorMessage);
+    if (result.log?.length) {
+        parts.push('Call log:');
+        parts.push(...result.log.map((l)=>`- ${l}`));
+    }
+    return parts.join('\n');
+};
+const escapeCssAttrValue = (value)=>value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+const getRunnerFrame = async (containerPage, testPath, timeoutMs)=>{
+    const selector = `iframe[data-test-file='${escapeCssAttrValue(testPath)}']`;
+    const iframe = containerPage.locator(selector);
+    const count = await iframe.count();
+    if (0 === count) {
+        const known = await containerPage.locator('iframe[data-test-file]').evaluateAll((nodes)=>nodes.map((n)=>n.dataset.testFile));
+        throw new Error(`Runner iframe not found for testPath: ${JSON.stringify(testPath)}. Known iframes: ${JSON.stringify(known)}. Timeout: ${timeoutMs}ms`);
+    }
+    return containerPage.frameLocator(selector);
+};
+const callExpect = async (locator, expectMethod, options, fallbackMessage)=>{
+    const result = await locator._expect(expectMethod, options);
+    if (!options.isNot !== result.matches) throw new Error(formatExpectError(result) || fallbackMessage);
+    return null;
+};
+const assertSerializedText = (value, matcherName)=>{
+    const t = value;
+    if (!t || 'string' !== t.type && 'regexp' !== t.type) throw new Error(`${matcherName} expects a serialized text matcher`);
+    return t;
+};
+const assertStringArg = (value, matcherName, label)=>{
+    if ('string' != typeof value || !value) throw new Error(`${matcherName} expects ${label}`);
+    return value;
+};
+const simpleMatchers = {
+    toBeVisible: 'to.be.visible',
+    toBeHidden: 'to.be.hidden',
+    toBeEnabled: 'to.be.enabled',
+    toBeDisabled: 'to.be.disabled',
+    toBeAttached: 'to.be.attached',
+    toBeDetached: 'to.be.detached',
+    toBeEditable: 'to.be.editable',
+    toBeFocused: 'to.be.focused',
+    toBeEmpty: 'to.be.empty'
+};
+const textMatchers = {
+    toHaveId: {
+        expectMethod: 'to.have.id'
+    },
+    toHaveText: {
+        expectMethod: 'to.have.text',
+        textOptions: {
+            normalizeWhiteSpace: true
+        }
+    },
+    toContainText: {
+        expectMethod: 'to.have.text',
+        textOptions: {
+            matchSubstring: true,
+            normalizeWhiteSpace: true
+        }
+    },
+    toHaveValue: {
+        expectMethod: 'to.have.value'
+    },
+    toHaveClass: {
+        expectMethod: 'to.have.class'
+    }
+};
+const dispatchExpectMatcher = (locator, request, isNot, timeout)=>{
+    const { method, args } = request;
+    const simpleExpect = simpleMatchers[method];
+    if (simpleExpect) return callExpect(locator, simpleExpect, {
+        isNot,
+        timeout
+    }, `Expected element ${method.replace('toBe', 'to be ').replace(/([A-Z])/g, ' $1').trim().toLowerCase()}`);
+    const textDef = textMatchers[method];
+    if (textDef) {
+        const expected = assertSerializedText(args[0], method);
+        return callExpect(locator, textDef.expectMethod, {
+            isNot,
+            timeout,
+            expectedText: serializeExpectedText(expected, textDef.textOptions)
+        }, `Expected element ${method}`);
+    }
+    switch(method){
+        case 'toBeInViewport':
+            {
+                const ratio = args[0];
+                if (void 0 !== ratio && 'number' != typeof ratio) throw new Error(`toBeInViewport expects ratio to be a number, got ${typeof ratio}`);
+                return callExpect(locator, 'to.be.in.viewport', {
+                    isNot,
+                    timeout,
+                    expectedNumber: ratio
+                }, 'Expected element to be in viewport');
+            }
+        case 'toBeChecked':
+            return callExpect(locator, 'to.be.checked', {
+                isNot,
+                timeout,
+                expectedValue: {
+                    checked: true
+                }
+            }, 'Expected element to be checked');
+        case 'toBeUnchecked':
+            return callExpect(locator, 'to.be.checked', {
+                isNot,
+                timeout,
+                expectedValue: {
+                    checked: false
+                }
+            }, 'Expected element to be unchecked');
+        case 'toHaveCount':
+            {
+                const expected = args[0];
+                if ('number' != typeof expected) throw new Error(`toHaveCount expects a number, got ${typeof expected}`);
+                return callExpect(locator, 'to.have.count', {
+                    isNot,
+                    timeout,
+                    expectedNumber: expected
+                }, `Expected count ${expected}`);
+            }
+        case 'toHaveAttribute':
+            {
+                const name = assertStringArg(args[0], 'toHaveAttribute', 'an attribute name');
+                if (args.length < 2) return callExpect(locator, 'to.have.attribute', {
+                    isNot,
+                    timeout,
+                    expressionArg: name
+                }, `Expected attribute ${name} to be present`);
+                const expected = assertSerializedText(args[1], 'toHaveAttribute');
+                return callExpect(locator, 'to.have.attribute.value', {
+                    isNot,
+                    timeout,
+                    expressionArg: name,
+                    expectedText: serializeExpectedText(expected)
+                }, `Expected attribute ${name} to match`);
+            }
+        case 'toHaveCSS':
+            {
+                const name = assertStringArg(args[0], 'toHaveCSS', 'a CSS property name');
+                const expected = assertSerializedText(args[1], 'toHaveCSS');
+                return callExpect(locator, 'to.have.css', {
+                    isNot,
+                    timeout,
+                    expressionArg: name,
+                    expectedText: serializeExpectedText(expected)
+                }, `Expected CSS ${name} to match`);
+            }
+        case 'toHaveJSProperty':
+            {
+                const name = assertStringArg(args[0], 'toHaveJSProperty', 'a property name');
+                const expectedValue = args[1];
+                try {
+                    JSON.stringify(expectedValue);
+                } catch  {
+                    throw new Error('toHaveJSProperty expects a JSON-serializable expected value');
+                }
+                return callExpect(locator, 'to.have.property', {
+                    isNot,
+                    timeout,
+                    expressionArg: name,
+                    expectedValue
+                }, `Expected JS property ${name} to match`);
+            }
+    }
+    throw new Error(`Unhandled expect matcher: ${method}`);
+};
+const dispatchConfigMethod = async (request)=>{
+    switch(request.method){
+        case 'setTestIdAttribute':
+            {
+                const attr = request.args[0];
+                if ('string' != typeof attr || !attr) throw new Error('setTestIdAttribute expects a non-empty string argument');
+                const playwright = await import("playwright");
+                playwright.selectors.setTestIdAttribute(attr);
+                return null;
+            }
+        default:
+            throw new Error(`Unknown config method: ${request.method}`);
+    }
+};
+async function dispatchPlaywrightBrowserRpc({ containerPage, runnerPage, request, timeoutFallbackMs }) {
+    if ('config' === request.kind) return dispatchConfigMethod(request);
+    const testPath = request.testPath;
+    if (!testPath) throw new Error('Browser RPC request is missing testPath');
+    const timeout = 'number' == typeof request.timeout ? request.timeout : timeoutFallbackMs;
+    const locatorRoot = runnerPage ? runnerPage : await getRunnerFrame(containerPage ?? (()=>{
+        throw new Error('Browser container page is not initialized');
+    })(), testPath, timeout);
+    const locator = compilePlaywrightLocator(locatorRoot, request.locator);
+    if ('locator' === request.kind) {
+        if (!supportedLocatorActions.has(request.method)) throw new Error(`Locator method not supported: ${request.method}`);
+        const target = locator;
+        return await target[request.method](...request.args);
+    }
+    if ('expect' === request.kind) {
+        if (!supportedExpectElementMatchers.has(request.method)) throw new Error(`Expect matcher not supported: ${request.method}`);
+        return dispatchExpectMatcher(locator, request, !!request.isNot, timeout);
+    }
+    throw new Error(`Unknown browser rpc kind: ${request.kind}`);
+}
+async function launchPlaywrightBrowser({ browserName, headless }) {
+    const playwright = await import("playwright");
+    const browserType = playwright[browserName];
+    const browser = await browserType.launch({
+        headless,
+        args: 'chromium' === browserName ? [
+            '--disable-popup-blocking',
+            '--no-first-run',
+            '--no-default-browser-check'
+        ] : void 0
+    });
+    return {
+        browser: browser
+    };
+}
+const playwrightProviderImplementation = {
+    name: 'playwright',
+    async launchRuntime ({ browserName, headless }) {
+        return launchPlaywrightBrowser({
+            browserName,
+            headless
+        });
+    },
+    async dispatchRpc ({ containerPage, runnerPage, request, timeoutFallbackMs }) {
+        return dispatchPlaywrightBrowserRpc({
+            containerPage: containerPage,
+            runnerPage: runnerPage,
+            request,
+            timeoutFallbackMs
+        });
+    }
+};
+const providerImplementations = {
+    playwright: playwrightProviderImplementation
+};
+function getBrowserProviderImplementation(provider) {
+    const implementation = providerImplementations[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 BROWSER_VIEWPORT_PRESET_IDS = [
+    'iPhoneSE',
+    'iPhoneXR',
+    'iPhone12Pro',
+    'iPhone14ProMax',
+    'Pixel7',
+    'SamsungGalaxyS8Plus',
+    'SamsungGalaxyS20Ultra',
+    'iPadMini',
+    'iPadAir',
+    'iPadPro',
+    'SurfacePro7',
+    'SurfaceDuo',
+    'GalaxyZFold5',
+    'AsusZenbookFold',
+    'SamsungGalaxyA51A71',
+    'NestHub',
+    'NestHubMax'
+];
+const BROWSER_VIEWPORT_PRESET_DIMENSIONS = {
+    iPhoneSE: {
+        width: 375,
+        height: 667
+    },
+    iPhoneXR: {
+        width: 414,
+        height: 896
+    },
+    iPhone12Pro: {
+        width: 390,
+        height: 844
+    },
+    iPhone14ProMax: {
+        width: 430,
+        height: 932
+    },
+    Pixel7: {
+        width: 412,
+        height: 915
+    },
+    SamsungGalaxyS8Plus: {
+        width: 360,
+        height: 740
+    },
+    SamsungGalaxyS20Ultra: {
+        width: 412,
+        height: 915
+    },
+    iPadMini: {
+        width: 768,
+        height: 1024
+    },
+    iPadAir: {
+        width: 820,
+        height: 1180
+    },
+    iPadPro: {
+        width: 1024,
+        height: 1366
+    },
+    SurfacePro7: {
+        width: 912,
+        height: 1368
+    },
+    SurfaceDuo: {
+        width: 540,
+        height: 720
+    },
+    GalaxyZFold5: {
+        width: 344,
+        height: 882
+    },
+    AsusZenbookFold: {
+        width: 853,
+        height: 1280
+    },
+    SamsungGalaxyA51A71: {
+        width: 412,
+        height: 914
+    },
+    NestHub: {
+        width: 1024,
+        height: 600
+    },
+    NestHubMax: {
+        width: 1280,
+        height: 800
+    }
+};
+const resolveBrowserViewportPreset = (presetId)=>{
+    const size = BROWSER_VIEWPORT_PRESET_DIMENSIONS[presetId];
+    return size ?? null;
+};
+const isTTY = ()=>Boolean(process.stdin.isTTY && !process.env.CI);
+const isBrowserWatchCliShortcutsEnabled = ()=>isTTY();
+const getBrowserWatchCliShortcutsHintMessage = ()=>`  ${color.dim('press')} ${color.bold('q')} ${color.dim('to quit')}\n`;
+const logBrowserWatchReadyMessage = (enableCliShortcuts)=>{
+    logger.log(color.green('  Waiting for file changes...'));
+    if (enableCliShortcuts) logger.log(getBrowserWatchCliShortcutsHintMessage());
+};
+async function setupBrowserWatchCliShortcuts({ close }) {
+    const { emitKeypressEvents } = await import("node:readline");
+    emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    let isClosing = false;
+    const handleKeypress = (str, key)=>{
+        if (key.ctrl && 'c' === key.name) return void process.kill(process.pid, 'SIGINT');
+        if (key.ctrl && 'z' === key.name) {
+            if ('win32' !== process.platform) process.kill(process.pid, 'SIGTSTP');
+            return;
+        }
+        if ('q' !== str || isClosing) return;
+        isClosing = true;
+        (async ()=>{
+            try {
+                await close();
+            } finally{
+                process.exit(0);
+            }
+        })();
+    };
+    process.stdin.on('keypress', handleKeypress);
+    return ()=>{
+        try {
+            process.stdin.setRawMode(false);
+            process.stdin.pause();
+        } catch  {}
+        process.stdin.off('keypress', handleKeypress);
+    };
+}
+const serializeTestFiles = (files)=>JSON.stringify(files.map((f)=>`${f.projectName}:${f.testPath}`).sort());
+const normalizeTestFiles = (files)=>files.map((file)=>({
+            ...file,
+            testPath: normalize(file.testPath)
+        }));
+const collectWatchTestFiles = (projectEntries)=>projectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
+                testPath: normalize(testPath),
+                projectName: entry.project.name
+            })));
+const planWatchRerun = ({ projectEntries, previousTestFiles, affectedTestFiles })=>{
+    const currentTestFiles = collectWatchTestFiles(projectEntries);
+    const normalizedPrevious = normalizeTestFiles(previousTestFiles);
+    const filesChanged = serializeTestFiles(currentTestFiles) !== serializeTestFiles(normalizedPrevious);
+    const normalizedAffectedTestFiles = affectedTestFiles.map((testFile)=>normalize(testFile));
+    const currentFileMap = new Map(currentTestFiles.map((file)=>[
+            file.testPath,
+            file
+        ]));
+    const matchedAffectedFiles = normalizedAffectedTestFiles.map((testFile)=>currentFileMap.get(testFile)).filter((file)=>Boolean(file));
+    return {
+        currentTestFiles,
+        filesChanged,
+        normalizedAffectedTestFiles,
+        affectedTestFiles: matchedAffectedFiles
+    };
+};
 const picomatch = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js");
 const { createRsbuild: createRsbuild, rspack: rspack } = rsbuild;
 const hostController_dirname = dirname(fileURLToPath(import.meta.url));
@@ -1682,12 +2638,68 @@ const watchContext = {
     lastTestFiles: [],
     hooksEnabled: false,
     cleanupRegistered: false,
+    cleanupPromise: null,
+    closeCliShortcuts: null,
     chunkHashes: new Map(),
     affectedTestFiles: []
 };
+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);
+    }
+    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 : [
+        arr
+    ];
+};
+const applyDefaultWatchOptions = (rspackConfig, isWatchMode)=>{
+    rspackConfig.watchOptions ??= {};
+    if (!isWatchMode) {
+        rspackConfig.watchOptions.ignored = '**/**';
+        return;
+    }
+    rspackConfig.watchOptions.ignored = castArray(rspackConfig.watchOptions.ignored || []);
+    if (0 === rspackConfig.watchOptions.ignored.length) rspackConfig.watchOptions.ignored.push('**/.git', '**/node_modules');
+    rspackConfig.output?.path && rspackConfig.watchOptions.ignored.push(rspackConfig.output.path);
+};
+const createBrowserLazyCompilationConfig = (setupFiles)=>{
+    const eagerSetupFiles = new Set(setupFiles.map((filePath)=>normalize(filePath)));
+    if (0 === eagerSetupFiles.size) return {
+        imports: true,
+        entries: false
+    };
+    return {
+        imports: true,
+        entries: false,
+        test (module) {
+            const filePath = module.nameForCondition?.();
+            return !filePath || !eagerSetupFiles.has(normalize(filePath));
+        }
+    };
+};
+const createBrowserRsbuildDevConfig = (isWatchMode)=>({
+        hmr: isWatchMode,
+        client: {
+            logLevel: 'error'
+        }
+    });
 const globToRegexp = (glob)=>{
     const regex = picomatch.makeRe(glob, {
         fastpaths: false,
@@ -1796,6 +2808,31 @@ const getRuntimeConfigFromProject = (project)=>{
     };
 };
 const getBrowserProjects = (context)=>context.projects.filter((project)=>project.normalizedConfig.browser.enabled);
+const getBrowserLaunchOptions = (project)=>({
+        provider: project.normalizedConfig.browser.provider,
+        browser: project.normalizedConfig.browser.browser,
+        headless: project.normalizedConfig.browser.headless,
+        port: project.normalizedConfig.browser.port,
+        strictPort: project.normalizedConfig.browser.strictPort
+    });
+const ensureConsistentBrowserLaunchOptions = (projects)=>{
+    if (0 === projects.length) throw new Error('No browser-enabled projects found.');
+    const firstProject = projects[0];
+    const firstOptions = getBrowserLaunchOptions(firstProject);
+    for (const project of projects.slice(1)){
+        const options = getBrowserLaunchOptions(project);
+        if (options.provider !== firstOptions.provider || options.browser !== firstOptions.browser || options.headless !== firstOptions.headless || options.port !== firstOptions.port || options.strictPort !== firstOptions.strictPort) throw new Error(`Browser launch config mismatch between projects "${firstProject.name}" and "${project.name}". All browser-enabled projects in one run must share provider/browser/headless/port/strictPort.`);
+    }
+    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)=>{
     const projectEntries = [];
     const browserProjects = getBrowserProjects(context);
@@ -1909,20 +2946,6 @@ const htmlTemplate = `<!DOCTYPE html>
   </body>
 </html>
 `;
-const fallbackSchedulerHtmlTemplate = `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <title>Rstest Browser Scheduler</title>
-    <script>
-      window.__RSTEST_BROWSER_OPTIONS__ = ${OPTIONS_PLACEHOLDER};
-    </script>
-  </head>
-  <body>
-    <script type="module" src="/container-static/js/scheduler.js"></script>
-  </body>
-</html>
-`;
 const VIRTUAL_MANIFEST_FILENAME = 'virtual-manifest.ts';
 const destroyBrowserRuntime = async (runtime)=>{
     try {
@@ -1939,21 +2962,28 @@ const destroyBrowserRuntime = async (runtime)=>{
         force: true
     }).catch(()=>{});
 };
-const registerWatchCleanup = ()=>{
-    if (watchContext.cleanupRegistered) return;
-    const cleanup = async ()=>{
+const cleanupWatchRuntime = ()=>{
+    if (watchContext.cleanupPromise) return watchContext.cleanupPromise;
+    watchContext.cleanupPromise = (async ()=>{
+        watchContext.closeCliShortcuts?.();
+        watchContext.closeCliShortcuts = null;
         if (!watchContext.runtime) return;
         await destroyBrowserRuntime(watchContext.runtime);
         watchContext.runtime = null;
-    };
+    })();
+    return watchContext.cleanupPromise;
+};
+const registerWatchCleanup = ()=>{
+    if (watchContext.cleanupRegistered) return;
     for (const signal of [
         'SIGINT',
-        'SIGTERM'
+        'SIGTERM',
+        'SIGTSTP'
     ])process.once(signal, ()=>{
-        cleanup();
+        cleanupWatchRuntime();
     });
     process.once('exit', ()=>{
-        cleanup();
+        cleanupWatchRuntime();
     });
     watchContext.cleanupRegistered = true;
 };
@@ -1962,24 +2992,25 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
         [manifestPath]: manifestSource
     });
     const containerHtmlTemplate = containerDistPath ? await promises.readFile(join(containerDistPath, 'index.html'), 'utf-8') : null;
-    const schedulerHtmlTemplate = containerDistPath ? await promises.readFile(join(containerDistPath, 'scheduler.html'), 'utf-8').catch(()=>null) : null;
     let injectedContainerHtml = null;
-    let injectedSchedulerHtml = null;
     let serializedOptions = 'null';
+    const dispatchHandlers = new Map();
     const setContainerOptions = (options)=>{
         serializedOptions = serializeForInlineScript(options);
         if (containerHtmlTemplate) injectedContainerHtml = containerHtmlTemplate.replace(OPTIONS_PLACEHOLDER, serializedOptions);
-        injectedSchedulerHtml = (schedulerHtmlTemplate || fallbackSchedulerHtmlTemplate).replace(OPTIONS_PLACEHOLDER, serializedOptions);
     };
     const browserProjects = getBrowserProjects(context);
-    const firstProject = browserProjects[0];
-    const userPlugins = firstProject?.normalizedConfig.plugins || [];
-    const userRsbuildConfig = firstProject?.normalizedConfig ?? {};
-    const browserConfig = firstProject?.normalizedConfig.browser ?? context.normalizedConfig.browser;
+    const projectByEnvironmentName = new Map(browserProjects.map((project)=>[
+            project.environmentName,
+            project
+        ]));
+    const userPlugins = browserProjects.flatMap((project)=>project.normalizedConfig.plugins || []);
+    const browserLaunchOptions = ensureConsistentBrowserLaunchOptions(browserProjects);
     const browserRuntimePath = fileURLToPath(import.meta.resolve('@rstest/core/browser-runtime'));
     const rstestInternalAliases = {
         '@rstest/browser-manifest': manifestPath,
         '@rstest/core': resolveBrowserFile('client/public.ts'),
+        '@rstest/browser': resolveBrowserFile('browser.ts'),
         '@rstest/core/browser-runtime': browserRuntimePath,
         '@sinonjs/fake-timers': resolveBrowserFile('client/fakeTimersStub.ts')
     };
@@ -1991,16 +3022,15 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
             plugins: userPlugins,
             server: {
                 printUrls: false,
-                port: browserConfig.port ?? 4000,
-                strictPort: browserConfig.strictPort
-            },
-            dev: {
-                client: {
-                    logLevel: 'error'
-                }
+                port: browserLaunchOptions.port ?? 4000,
+                strictPort: browserLaunchOptions.strictPort
             },
+            dev: createBrowserRsbuildDevConfig(isWatchMode),
             environments: {
-                [firstProject?.environmentName || 'web']: {}
+                ...Object.fromEntries(browserProjects.map((project)=>[
+                        project.environmentName,
+                        {}
+                    ]))
             }
         }
     });
@@ -2008,12 +3038,27 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
         {
             name: 'rstest:browser-user-config',
             setup (api) {
+                api.expose?.('rstest:browser', {
+                    registerDispatchHandler: (namespace, handler)=>{
+                        dispatchHandlers.set(namespace, handler);
+                    }
+                });
                 api.modifyEnvironmentConfig({
-                    handler: (config, { mergeEnvironmentConfig })=>{
+                    handler: (config, { mergeEnvironmentConfig, name })=>{
+                        const project = projectByEnvironmentName.get(name);
+                        if (!project) return config;
+                        const userRsbuildConfig = project.normalizedConfig;
+                        const setupFiles = Object.values(getSetupFiles(project.normalizedConfig.setupFiles, project.rootPath));
                         const merged = mergeEnvironmentConfig(config, userRsbuildConfig, {
                             resolve: {
                                 alias: rstestInternalAliases
                             },
+                            source: {
+                                define: {
+                                    'process.env': 'globalThis[Symbol.for("rstest.env")]',
+                                    'import.meta.env': 'globalThis[Symbol.for("rstest.env")]'
+                                }
+                            },
                             output: {
                                 target: 'web',
                                 sourceMap: {
@@ -2023,12 +3068,10 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
                             tools: {
                                 rspack: (rspackConfig)=>{
                                     rspackConfig.mode = 'development';
-                                    rspackConfig.lazyCompilation = {
-                                        imports: true,
-                                        entries: false
-                                    };
+                                    rspackConfig.lazyCompilation = createBrowserLazyCompilationConfig(setupFiles);
                                     rspackConfig.plugins = rspackConfig.plugins || [];
                                     rspackConfig.plugins.push(virtualManifestPlugin);
+                                    applyDefaultWatchOptions(rspackConfig, isWatchMode);
                                     const browserRuntimeDir = dirname(browserRuntimePath);
                                     rspackConfig.module = rspackConfig.module || {};
                                     rspackConfig.module.rules = rspackConfig.module.rules || [];
@@ -2063,7 +3106,7 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
                 api.onAfterDevCompile(async ({ stats })=>{
                     if (stats) {
                         const projectEntries = await collectProjectEntries(context);
-                        const entryTestFiles = new Set(projectEntries.flatMap((entry)=>entry.testFiles.map((f)=>normalize(f))));
+                        const entryTestFiles = new Set(collectWatchTestFiles(projectEntries).map((file)=>file.testPath));
                         const statsJson = stats.toJson({
                             all: true
                         });
@@ -2077,7 +3120,7 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
             }
         }
     ]);
-    const coverage = firstProject?.normalizedConfig.coverage;
+    const coverage = browserProjects.find((project)=>project.normalizedConfig.coverage?.enabled)?.normalizedConfig.coverage;
     if (coverage?.enabled && 'list' !== context.command) {
         const { pluginCoverage } = await loadCoverageProvider(coverage, context.rootPath);
         rsbuildInstance.addPlugins([
@@ -2157,13 +3200,8 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
             }
             return;
         }
-        if ('/' === url.pathname || '/scheduler.html' === url.pathname) {
+        if ('/' === url.pathname) {
             if (await respondWithDevServerHtml(url, res)) return;
-            if ('/scheduler.html' === url.pathname) {
-                res.setHeader('Content-Type', 'text/html');
-                res.end(injectedSchedulerHtml || (schedulerHtmlTemplate || fallbackSchedulerHtmlTemplate).replace(OPTIONS_PLACEHOLDER, 'null'));
-                return;
-            }
             const html = injectedContainerHtml || containerHtmlTemplate?.replace(OPTIONS_PLACEHOLDER, 'null');
             if (html) {
                 res.setHeader('Content-Type', 'text/html');
@@ -2198,43 +3236,31 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
     });
     const wsPort = wss.address().port;
     logger.debug(`[Browser UI] WebSocket server started on port ${wsPort}`);
-    let browserLauncher;
-    const browserName = browserConfig.browser;
+    const browserName = browserLaunchOptions.browser ?? 'chromium';
     try {
-        const playwright = await import("playwright");
-        browserLauncher = playwright[browserName];
-    } catch (_error) {
-        wss.close();
-        await devServer.close();
-        throw _error;
-    }
-    let browser;
-    try {
-        browser = await browserLauncher.launch({
-            headless: forceHeadless ?? browserConfig.headless,
-            args: 'chromium' === browserName ? [
-                '--disable-popup-blocking',
-                '--no-first-run',
-                '--no-default-browser-check'
-            ] : void 0
+        const providerImplementation = getBrowserProviderImplementation(browserLaunchOptions.provider);
+        const runtime = await providerImplementation.launchRuntime({
+            browserName,
+            headless: forceHeadless ?? browserLaunchOptions.headless
         });
+        return {
+            rsbuildInstance,
+            devServer,
+            browser: runtime.browser,
+            port,
+            wsPort,
+            manifestPath,
+            tempDir,
+            manifestPlugin: virtualManifestPlugin,
+            setContainerOptions,
+            dispatchHandlers,
+            wss
+        };
     } catch (_error) {
         wss.close();
         await devServer.close();
         throw _error;
     }
-    return {
-        rsbuildInstance,
-        devServer,
-        browser,
-        port,
-        wsPort,
-        manifestPath,
-        tempDir,
-        manifestPlugin: virtualManifestPlugin,
-        setContainerOptions,
-        wss
-    };
 };
 async function resolveProjectEntries(context, shardedEntries) {
     if (shardedEntries) {
@@ -2259,8 +3285,36 @@ const runBrowserController = async (context, options)=>{
     const { skipOnTestRunEnd = false } = options ?? {};
     const buildStart = Date.now();
     const browserProjects = getBrowserProjects(context);
-    const useSchedulerPage = browserProjects.every((project)=>project.normalizedConfig.browser.headless);
-    const buildErrorResult = async (error)=>{
+    const useHeadlessDirect = browserProjects.every((project)=>project.normalizedConfig.browser.headless);
+    const browserSourceMapCache = new Map();
+    const isHttpLikeFile = (file)=>/^https?:\/\//.test(file);
+    const resolveBrowserSourcemap = async (sourcePath)=>{
+        if (!isHttpLikeFile(sourcePath)) return {
+            handled: false,
+            sourcemap: null
+        };
+        const normalizedUrl = normalizeJavaScriptUrl(sourcePath);
+        if (!normalizedUrl) return {
+            handled: true,
+            sourcemap: null
+        };
+        if (browserSourceMapCache.has(normalizedUrl)) return {
+            handled: true,
+            sourcemap: browserSourceMapCache.get(normalizedUrl) ?? null
+        };
+        return {
+            handled: true,
+            sourcemap: await loadSourceMapWithCache({
+                jsUrl: normalizedUrl,
+                cache: browserSourceMapCache
+            })
+        };
+    };
+    const getBrowserSourcemap = async (sourcePath)=>{
+        const result = await resolveBrowserSourcemap(sourcePath);
+        return result.handled ? result.sourcemap : null;
+    };
+    const buildErrorResult = async (error, close)=>{
         const elapsed = Math.max(0, Date.now() - buildStart);
         const errorResult = {
             results: [],
@@ -2273,14 +3327,17 @@ const runBrowserController = async (context, options)=>{
             hasFailure: true,
             unhandledErrors: [
                 error
-            ]
+            ],
+            getSourcemap: getBrowserSourcemap,
+            resolveSourcemap: resolveBrowserSourcemap,
+            close
         };
         if (!skipOnTestRunEnd) for (const reporter of context.reporters)await reporter.onTestRunEnd?.({
             results: [],
             testResults: [],
             duration: errorResult.duration,
             snapshotSummary: context.snapshotManager.summary,
-            getSourcemap: async ()=>null,
+            getSourcemap: getBrowserSourcemap,
             unhandledErrors: errorResult.unhandledErrors
         });
         return errorResult;
@@ -2288,24 +3345,51 @@ const runBrowserController = async (context, options)=>{
     const toError = (error)=>error instanceof Error ? error : new Error(String(error));
     const failWithError = async (error, cleanup)=>{
         ensureProcessExitCode(1);
-        await cleanup?.();
-        return buildErrorResult(toError(error));
+        const normalizedError = toError(error);
+        if (cleanup && skipOnTestRunEnd) return buildErrorResult(normalizedError, cleanup);
+        try {
+            return await buildErrorResult(normalizedError);
+        } finally{
+            await cleanup?.();
+        }
+    };
+    const collectDeletedTestPaths = (previous, current)=>{
+        const currentPathSet = new Set(current.map((file)=>file.testPath));
+        return previous.map((file)=>file.testPath).filter((testPath)=>!currentPathSet.has(testPath));
+    };
+    const notifyTestRunStart = async ()=>{
+        if (skipOnTestRunEnd) return;
+        for (const reporter of context.reporters)await reporter.onTestRunStart?.();
+    };
+    const notifyTestRunEnd = async ({ duration, unhandledErrors, filterRerunTestPaths })=>{
+        if (skipOnTestRunEnd) return;
+        for (const reporter of context.reporters)await reporter.onTestRunEnd?.({
+            results: context.reporterResults.results,
+            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 (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);
+    if (!useHeadlessDirect) {
+        if (containerDevServerEnv) try {
+            containerDevServer = new URL(containerDevServerEnv).toString();
+            logger.debug(`[Browser UI] Using dev server for container: ${containerDevServer}`);
+        } catch (error) {
+            const originalError = toError(error);
+            originalError.message = `Invalid RSTEST_CONTAINER_DEV_SERVER value: ${originalError.message}`;
+            return failWithError(originalError);
+        }
+        if (!containerDevServer) try {
+            containerDistPath = resolveContainerDist();
+        } catch (error) {
+            return failWithError(error);
+        }
     }
     const projectEntries = await resolveProjectEntries(context, options?.shardedEntries);
     const totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
@@ -2319,17 +3403,16 @@ const runBrowserController = async (context, options)=>{
         if (0 !== code) ensureProcessExitCode(code);
         return;
     }
+    await notifyTestRunStart();
     const isWatchMode = 'watch' === context.command;
+    const enableCliShortcuts = isWatchMode && isBrowserWatchCliShortcutsEnabled();
     const tempDir = isWatchMode && watchContext.runtime ? watchContext.runtime.tempDir : isWatchMode ? join(context.rootPath, TEMP_RSTEST_OUTPUT_DIR, 'browser', 'watch') : join(context.rootPath, TEMP_RSTEST_OUTPUT_DIR, 'browser', Date.now().toString());
     const manifestPath = join(tempDir, VIRTUAL_MANIFEST_FILENAME);
     const manifestSource = generateManifestModule({
         manifestPath,
         entries: projectEntries
     });
-    if (isWatchMode) watchContext.lastTestFiles = projectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
-                testPath,
-                projectName: entry.project.name
-            })));
+    if (isWatchMode) watchContext.lastTestFiles = collectWatchTestFiles(projectEntries);
     let runtime = isWatchMode ? watchContext.runtime : null;
     let triggerRerun;
     if (!runtime) {
@@ -2357,6 +3440,9 @@ const runBrowserController = async (context, options)=>{
         if (isWatchMode) {
             watchContext.runtime = runtime;
             registerWatchCleanup();
+            if (enableCliShortcuts && !watchContext.closeCliShortcuts) watchContext.closeCliShortcuts = await setupBrowserWatchCliShortcuts({
+                close: cleanupWatchRuntime
+            });
         }
     }
     const { browser, port, wsPort, wss } = runtime;
@@ -2384,15 +3470,496 @@ const runBrowserController = async (context, options)=>{
         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
+        });
+        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');
+        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);
+        }
+    };
+    runtime.dispatchHandlers.set('browser', async (dispatchRequest)=>{
+        const request = validateBrowserRpcRequest(dispatchRequest.args);
+        return dispatchBrowserRpcRequest({
+            request,
+            target: dispatchRequest.target
+        });
+    });
     runtime.setContainerOptions(hostOptions);
     const reporterResults = [];
     const caseResults = [];
-    let completedTests = 0;
     let fatalError = null;
-    let resolveAllTests;
-    const allTestsPromise = new Promise((resolve)=>{
-        resolveAllTests = resolve;
-    });
+    const snapshotRpcMethods = {
+        async resolveSnapshotPath (testPath) {
+            const snapExtension = '.snap';
+            const resolver = context.normalizedConfig.resolveSnapshotPath || (()=>join(dirname(testPath), '__snapshots__', `${basename(testPath)}${snapExtension}`));
+            return resolver(testPath, snapExtension);
+        },
+        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 handleTestFileStart = async (payload)=>{
+        await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileStart?.({
+                testPath: payload.testPath,
+                tests: []
+            })));
+    };
+    const handleTestFileReady = async (payload)=>{
+        await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileReady?.(payload)));
+    };
+    const handleTestSuiteStart = async (payload)=>{
+        await Promise.all(context.reporters.map((reporter)=>reporter.onTestSuiteStart?.(payload)));
+    };
+    const handleTestSuiteResult = async (payload)=>{
+        await Promise.all(context.reporters.map((reporter)=>reporter.onTestSuiteResult?.(payload)));
+    };
+    const handleTestCaseStart = async (payload)=>{
+        await Promise.all(context.reporters.map((reporter)=>reporter.onTestCaseStart?.(payload)));
+    };
+    const handleTestCaseResult = async (payload)=>{
+        caseResults.push(payload);
+        await Promise.all(context.reporters.map((reporter)=>reporter.onTestCaseResult?.(payload)));
+    };
+    const handleTestFileComplete = async (payload)=>{
+        reporterResults.push(payload);
+        context.updateReporterResultState([
+            payload
+        ], payload.results);
+        if (payload.snapshotResult) context.snapshotManager.add(payload.snapshotResult);
+        await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileResult?.(payload)));
+        if ('fail' === payload.status) ensureProcessExitCode(1);
+    };
+    const handleLog = async (payload)=>{
+        const log = {
+            content: payload.content,
+            name: payload.level,
+            testPath: payload.testPath,
+            type: payload.type,
+            trace: payload.trace
+        };
+        const shouldLog = context.normalizedConfig.onConsoleLog?.(log.content) ?? true;
+        if (shouldLog) await Promise.all(context.reporters.map((reporter)=>reporter.onUserConsoleLog?.(log)));
+    };
+    const handleFatal = async (payload)=>{
+        const error = new Error(payload.message);
+        error.stack = payload.stack;
+        fatalError = error;
+        ensureProcessExitCode(1);
+    };
+    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:
+                return;
+        }
+    };
+    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`);
+            }
+        });
+    if (useHeadlessDirect) {
+        const viewportByProject = mapViewportByProject(projectRuntimeConfigs);
+        const runLifecycle = new RunSessionLifecycle();
+        const sessionRegistry = new RunnerSessionRegistry();
+        getHeadlessRunnerPageBySessionId = (sessionId)=>sessionRegistry.getById(sessionId)?.page;
+        let dispatchRequestCounter = 0;
+        const nextDispatchRequestId = (namespace)=>`${namespace}-${++dispatchRequestCounter}`;
+        const closeContextSafely = async (browserContext)=>{
+            try {
+                await browserContext.close();
+            } catch  {}
+        };
+        const cancelRun = async (run, waitForDone = true)=>{
+            await runLifecycle.cancel(run, {
+                waitForDone,
+                onCancel: async (session)=>{
+                    await Promise.all(Array.from(session.contexts).map((browserContext)=>closeContextSafely(browserContext)));
+                }
+            });
+        };
+        const dispatchRouter = createDispatchRouter({
+            isRunTokenStale: (runToken)=>runLifecycle.isTokenStale(runToken),
+            onStale: (request)=>{
+                if (request.namespace === DISPATCH_NAMESPACE_RUNNER) 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: DISPATCH_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({
+                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 projectRuntime = projectRuntimeConfigs.find((project)=>project.name === file.projectName);
+            const perFileTimeoutMs = (projectRuntime?.runtimeConfig.testTimeout ?? maxTestTimeoutForRpc) + 30000;
+            let timeoutId;
+            try {
+                page = await browserContext.newPage();
+                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,
+                    testFile: file.testPath,
+                    runId: `${run.token}:${session.id}`
+                };
+                const serializedOptions = serializeForInlineScript(inlineOptions);
+                await page.addInitScript(`window.__RSTEST_BROWSER_OPTIONS__ = ${serializedOptions};`);
+                await page.goto(`http://localhost:${port}/runner.html`, {
+                    waitUntil: 'load'
+                });
+                const timeoutPromise = new Promise((resolve)=>{
+                    timeoutId = setTimeout(()=>resolve('timeout'), perFileTimeoutMs);
+                });
+                const state = await Promise.race([
+                    donePromise.then(()=>'done'),
+                    timeoutPromise,
+                    run.cancelSignal.then(()=>'cancelled')
+                ]);
+                if ('cancelled' === state) return;
+                if ('timeout' === state && runLifecycle.isTokenActive(run.token) && !run.cancelled) {
+                    await handleFatal({
+                        message: `Test execution timeout after ${perFileTimeoutMs / 1000}s for ${file.testPath}.`
+                    });
+                    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 (timeoutId) clearTimeout(timeoutId);
+                if (page) try {
+                    await page.close();
+                } catch  {}
+                if (sessionId) sessionRegistry.deleteById(sessionId);
+                run.contexts.delete(browserContext);
+                await closeContextSafely(browserContext);
+            }
+        };
+        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 worker = async ()=>{
+                while(queue.length > 0 && !run.cancelled && runLifecycle.isTokenActive(run.token)){
+                    const next = queue.shift();
+                    if (!next) return;
+                    await runSingleFile(run, next);
+                }
+            };
+            run.done = Promise.all(Array.from({
+                length: Math.min(queue.length, Math.max(concurrency, 1))
+            }, ()=>worker())).then(()=>{});
+            await run.done;
+            runLifecycle.clearIfActive(run);
+        };
+        const latestRerunScheduler = createHeadlessLatestRerunScheduler({
+            getActiveRun: ()=>runLifecycle.activeSession,
+            isRunCancelled: (run)=>run.cancelled,
+            invalidateActiveRun: ()=>{
+                runLifecycle.invalidateActiveToken();
+            },
+            interruptActiveRun: async (run)=>{
+                await cancelRun(run, false);
+            },
+            runFiles: async (files)=>{
+                await notifyTestRunStart();
+                const rerunStartTime = Date.now();
+                const fatalErrorBeforeRun = fatalError;
+                let rerunError;
+                try {
+                    await runFilesWithPool(files);
+                } catch (error) {
+                    rerunError = toError(error);
+                    throw error;
+                } finally{
+                    const testTime = Math.max(0, Date.now() - rerunStartTime);
+                    const rerunFatalError = fatalError && fatalError !== fatalErrorBeforeRun ? fatalError : void 0;
+                    await notifyTestRunEnd({
+                        duration: {
+                            totalTime: testTime,
+                            buildTime: 0,
+                            testTime
+                        },
+                        filterRerunTestPaths: files.map((file)=>file.testPath),
+                        unhandledErrors: rerunError ? [
+                            rerunError
+                        ] : rerunFatalError ? [
+                            rerunFatalError
+                        ] : void 0
+                    });
+                    logBrowserWatchReadyMessage(enableCliShortcuts);
+                }
+            },
+            onError: async (error)=>{
+                const formatted = toError(error);
+                await handleFatal({
+                    message: formatted.message,
+                    stack: formatted.stack
+                });
+            },
+            onInterrupt: (run)=>{
+                logger.debug(`[Headless] Interrupting active run token ${run.token} before scheduling latest rerun`);
+            }
+        });
+        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: watchContext.lastTestFiles,
+                affectedTestFiles: watchContext.affectedTestFiles
+            });
+            watchContext.affectedTestFiles = [];
+            if (rerunPlan.filesChanged) {
+                const deletedTestPaths = collectDeletedTestPaths(watchContext.lastTestFiles, rerunPlan.currentTestFiles);
+                if (deletedTestPaths.length > 0) context.updateReporterResultState([], [], deletedTestPaths);
+                watchContext.lastTestFiles = rerunPlan.currentTestFiles;
+                if (0 === rerunPlan.currentTestFiles.length) {
+                    await latestRerunScheduler.enqueueLatest([]);
+                    logger.log(color.cyan('No browser test files remain after update.\n'));
+                    logBrowserWatchReadyMessage(enableCliShortcuts);
+                    return;
+                }
+                logger.log(color.cyan(`Test file set changed, re-running ${rerunPlan.currentTestFiles.length} file(s)...\n`));
+                latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
+                return;
+            }
+            if (0 === rerunPlan.affectedTestFiles.length) {
+                logger.log(color.cyan('No affected browser test files detected, skipping re-run.\n'));
+                logBrowserWatchReadyMessage(enableCliShortcuts);
+                return;
+            }
+            logger.log(color.cyan(`Re-running ${rerunPlan.affectedTestFiles.length} affected test file(s)...\n`));
+            latestRerunScheduler.enqueueLatest(rerunPlan.affectedTestFiles);
+        };
+        const closeHeadlessRuntime = isWatchMode ? void 0 : async ()=>{
+            sessionRegistry.clear();
+            await destroyBrowserRuntime(runtime);
+        };
+        if (fatalError) return failWithError(fatalError, closeHeadlessRuntime);
+        const duration = {
+            totalTime: buildTime + testTime,
+            buildTime,
+            testTime
+        };
+        context.updateReporterResultState(reporterResults, caseResults);
+        const isFailure = reporterResults.some((result)=>'fail' === result.status);
+        if (isFailure) ensureProcessExitCode(1);
+        const result = {
+            results: reporterResults,
+            testResults: caseResults,
+            duration,
+            hasFailure: isFailure,
+            getSourcemap: getBrowserSourcemap,
+            resolveSourcemap: resolveBrowserSourcemap,
+            close: skipOnTestRunEnd ? closeHeadlessRuntime : void 0
+        };
+        if (!skipOnTestRunEnd) try {
+            await notifyTestRunEnd({
+                duration
+            });
+        } finally{
+            await closeHeadlessRuntime?.();
+        }
+        if (isWatchMode && triggerRerun) {
+            watchContext.hooksEnabled = true;
+            logBrowserWatchReadyMessage(enableCliShortcuts);
+        }
+        return result;
+    }
+    let currentTestFiles = allTestFiles;
+    const RUNNER_FRAMES_READY_TIMEOUT_MS = 30000;
+    let currentRunnerFramesSignature = null;
+    const runnerFramesWaiters = new Map();
+    const createTestFilesSignature = (testFiles)=>JSON.stringify(testFiles.map((testFile)=>normalize(testFile)));
+    const markRunnerFramesReady = (testFiles)=>{
+        const signature = createTestFilesSignature(testFiles);
+        currentRunnerFramesSignature = signature;
+        const waiters = runnerFramesWaiters.get(signature);
+        if (!waiters) return;
+        runnerFramesWaiters.delete(signature);
+        for (const waiter of waiters)waiter();
+    };
+    const waitForRunnerFramesReady = async (testFiles)=>{
+        const signature = createTestFilesSignature(testFiles);
+        if (currentRunnerFramesSignature === signature) return;
+        await new Promise((resolve, reject)=>{
+            const waiters = runnerFramesWaiters.get(signature) ?? new Set();
+            let timeoutId;
+            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();
+            };
+            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;
+    };
+    const getHeadedPerFileTimeoutMs = (file)=>{
+        const projectRuntime = projectRuntimeConfigs.find((project)=>project.name === file.projectName);
+        return (projectRuntime?.runtimeConfig.testTimeout ?? maxTestTimeoutForRpc) + 30000;
+    };
     let containerContext;
     let containerPage;
     let isNewPage = false;
@@ -2418,76 +3985,62 @@ const runBrowserController = async (context, options)=>{
         }
         containerPage.on('console', (msg)=>{
             const text = msg.text();
-            if (text.startsWith('[Container]') || text.startsWith('[Runner]') || text.startsWith('[Scheduler]')) logger.log(color.gray(`[Browser Console] ${text}`));
+            if (text.startsWith('[Container]') || text.startsWith('[Runner]')) logger.log(color.gray(`[Browser Console] ${text}`));
         });
     }
+    activeContainerPage = containerPage;
+    const dispatchRouter = createDispatchRouter();
+    const headedReloadQueue = createHeadedSerialTaskQueue();
+    let enqueueHeadedReload = async (_file, _testNamePattern)=>{
+        throw new Error('Headed reload queue is not initialized');
+    };
+    const reloadTestFileWithTimeout = async (file, testNamePattern)=>{
+        const timeoutMs = getHeadedPerFileTimeoutMs(file);
+        let timeoutId;
+        try {
+            await Promise.race([
+                rpcManager.reloadTestFile(file.testPath, testNamePattern),
+                new Promise((_, reject)=>{
+                    timeoutId = setTimeout(()=>{
+                        reject(new Error(`Headed test execution timeout after ${timeoutMs / 1000}s for ${file.testPath}.`));
+                    }, timeoutMs);
+                })
+            ]);
+        } finally{
+            if (timeoutId) clearTimeout(timeoutId);
+        }
+    };
     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 rpcManager.reloadTestFile(testFile, testNamePattern);
+                await enqueueHeadedReload(getTestFileInfo(testFile), testNamePattern);
             },
             async getTestFiles () {
-                return allTestFiles;
+                return currentTestFiles;
+            },
+            async onRunnerFramesReady (testFiles) {
+                markRunnerFramesReady(testFiles);
             },
             async onTestFileStart (payload) {
-                await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileStart?.({
-                        testPath: payload.testPath,
-                        tests: []
-                    })));
+                await handleTestFileStart(payload);
             },
             async onTestCaseResult (payload) {
-                caseResults.push(payload);
-                await Promise.all(context.reporters.map((reporter)=>reporter.onTestCaseResult?.(payload)));
+                await handleTestCaseResult(payload);
             },
             async onTestFileComplete (payload) {
-                reporterResults.push(payload);
-                if (payload.snapshotResult) context.snapshotManager.add(payload.snapshotResult);
-                await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileResult?.(payload)));
-                completedTests++;
-                if (completedTests >= allTestFiles.length && resolveAllTests) resolveAllTests();
+                await handleTestFileComplete(payload);
             },
             async onLog (payload) {
-                const log = {
-                    content: payload.content,
-                    name: payload.level,
-                    testPath: payload.testPath,
-                    type: payload.type,
-                    trace: payload.trace
-                };
-                const shouldLog = context.normalizedConfig.onConsoleLog?.(log.content) ?? true;
-                if (shouldLog) await Promise.all(context.reporters.map((reporter)=>reporter.onUserConsoleLog?.(log)));
+                await handleLog(payload);
             },
             async onFatal (payload) {
-                fatalError = new Error(payload.message);
-                fatalError.stack = payload.stack;
-                if (resolveAllTests) resolveAllTests();
-            },
-            async resolveSnapshotPath (testPath) {
-                const snapExtension = '.snap';
-                const resolver = context.normalizedConfig.resolveSnapshotPath || (()=>join(dirname(testPath), '__snapshots__', `${basename(testPath)}${snapExtension}`));
-                return resolver(testPath, snapExtension);
-            },
-            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');
+                await handleFatal(payload);
             },
-            async removeSnapshotFile (filepath) {
-                try {
-                    await promises.unlink(filepath);
-                } catch  {}
+            async dispatch (request) {
+                return dispatchRouter.dispatch(request);
             }
         });
     let rpcManager;
@@ -2501,52 +4054,80 @@ const runBrowserController = async (context, options)=>{
         if (isWatchMode) runtime.rpcManager = rpcManager;
     }
     if (isNewPage) {
-        const pagePath = useSchedulerPage ? '/scheduler.html' : '/';
-        if (useSchedulerPage) {
-            const serializedOptions = serializeForInlineScript(hostOptions);
-            await containerPage.addInitScript(`window.__RSTEST_BROWSER_OPTIONS__ = ${serializedOptions};`);
-        }
+        const pagePath = '/';
         await containerPage.goto(`http://localhost:${port}${pagePath}`, {
             waitUntil: 'load'
         });
         logger.log(color.cyan(`\nBrowser mode opened at http://localhost:${port}${pagePath}\n`));
     }
-    const maxTestTimeout = Math.max(...browserProjects.map((p)=>p.normalizedConfig.testTimeout ?? 5000));
-    const totalTimeoutMs = maxTestTimeout * allTestFiles.length + 30000;
-    let timeoutId;
-    const testTimeout = new Promise((resolve)=>{
-        timeoutId = setTimeout(()=>{
-            logger.log(color.yellow(`\nTest execution timeout after ${totalTimeoutMs / 1000}s. Completed: ${completedTests}/${allTestFiles.length}\n`));
-            resolve();
-        }, totalTimeoutMs);
-    });
+    enqueueHeadedReload = async (file, testNamePattern)=>headedReloadQueue.enqueue(async ()=>{
+            if (fatalError) return;
+            await reloadTestFileWithTimeout(file, testNamePattern);
+        });
     const testStart = Date.now();
-    await Promise.race([
-        allTestsPromise,
-        testTimeout
-    ]);
-    if (timeoutId) clearTimeout(timeoutId);
+    try {
+        await waitForRunnerFramesReady(currentTestFiles.map((file)=>file.testPath));
+        for (const file of currentTestFiles){
+            await enqueueHeadedReload(file);
+            if (fatalError) break;
+        }
+    } catch (error) {
+        fatalError = fatalError ?? toError(error);
+        ensureProcessExitCode(1);
+    }
     const testTime = Date.now() - testStart;
     if (isWatchMode) triggerRerun = async ()=>{
         const newProjectEntries = await collectProjectEntries(context);
-        const currentTestFiles = newProjectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
-                    testPath: normalize(testPath),
-                    projectName: entry.project.name
-                })));
-        const serialize = (files)=>JSON.stringify(files.map((f)=>`${f.projectName}:${f.testPath}`).sort());
-        const filesChanged = serialize(currentTestFiles) !== serialize(watchContext.lastTestFiles);
-        if (filesChanged) {
-            watchContext.lastTestFiles = currentTestFiles;
+        const rerunPlan = planWatchRerun({
+            projectEntries: newProjectEntries,
+            previousTestFiles: watchContext.lastTestFiles,
+            affectedTestFiles: watchContext.affectedTestFiles
+        });
+        watchContext.affectedTestFiles = [];
+        if (rerunPlan.filesChanged) {
+            const deletedTestPaths = collectDeletedTestPaths(watchContext.lastTestFiles, rerunPlan.currentTestFiles);
+            if (deletedTestPaths.length > 0) context.updateReporterResultState([], [], deletedTestPaths);
+            watchContext.lastTestFiles = rerunPlan.currentTestFiles;
+            currentTestFiles = rerunPlan.currentTestFiles;
             await rpcManager.notifyTestFileUpdate(currentTestFiles);
+            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 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 notifyTestRunEnd({
+                    duration: {
+                        totalTime: testTime,
+                        buildTime: 0,
+                        testTime
+                    },
+                    filterRerunTestPaths: rerunPlan.normalizedAffectedTestFiles,
+                    unhandledErrors: rerunError ? [
+                        rerunError
+                    ] : rerunFatalError ? [
+                        rerunFatalError
+                    ] : void 0
+                });
+                logBrowserWatchReadyMessage(enableCliShortcuts);
+            }
+        } else if (rerunPlan.filesChanged) logBrowserWatchReadyMessage(enableCliShortcuts);
+        else {
+            logger.log(color.cyan('Tests will be re-executed automatically\n'));
+            logBrowserWatchReadyMessage(enableCliShortcuts);
         }
-        const affectedFiles = watchContext.affectedTestFiles;
-        watchContext.affectedTestFiles = [];
-        if (affectedFiles.length > 0) {
-            logger.log(color.cyan(`Re-running ${affectedFiles.length} affected test file(s)...\n`));
-            for (const testFile of affectedFiles)await rpcManager.reloadTestFile(testFile);
-        } else if (!filesChanged) logger.log(color.cyan('Tests will be re-executed automatically\n'));
     };
-    if (!isWatchMode) {
+    const closeContainerRuntime = isWatchMode ? void 0 : async ()=>{
         try {
             await containerPage.close();
         } catch  {}
@@ -2554,8 +4135,8 @@ const runBrowserController = async (context, options)=>{
             await containerContext.close();
         } catch  {}
         await destroyBrowserRuntime(runtime);
-    }
-    if (fatalError) return failWithError(fatalError);
+    };
+    if (fatalError) return failWithError(fatalError, closeContainerRuntime);
     const duration = {
         totalTime: buildTime + testTime,
         buildTime,
@@ -2568,18 +4149,21 @@ const runBrowserController = async (context, options)=>{
         results: reporterResults,
         testResults: caseResults,
         duration,
-        hasFailure: isFailure
+        hasFailure: isFailure,
+        getSourcemap: getBrowserSourcemap,
+        resolveSourcemap: resolveBrowserSourcemap,
+        close: skipOnTestRunEnd ? closeContainerRuntime : void 0
     };
-    if (!skipOnTestRunEnd) for (const reporter of context.reporters)await reporter.onTestRunEnd?.({
-        results: context.reporterResults.results,
-        testResults: context.reporterResults.testResults,
-        duration,
-        snapshotSummary: context.snapshotManager.summary,
-        getSourcemap: async ()=>null
-    });
+    if (!skipOnTestRunEnd) try {
+        await notifyTestRunEnd({
+            duration
+        });
+    } finally{
+        await closeContainerRuntime?.();
+    }
     if (isWatchMode && triggerRerun) {
         watchContext.hooksEnabled = true;
-        logger.log(color.cyan('\nWatch mode enabled - will re-run tests on file changes\n'));
+        logBrowserWatchReadyMessage(enableCliShortcuts);
     }
     return result;
 };
@@ -2596,6 +4180,7 @@ const listBrowserTests = async (context, options)=>{
         manifestPath,
         entries: projectEntries
     });
+    const browserProjects = getBrowserProjects(context);
     let runtime;
     try {
         runtime = await createBrowserRuntime({
@@ -2609,11 +4194,13 @@ const listBrowserTests = async (context, options)=>{
             forceHeadless: true
         });
     } catch (error) {
-        logger.error(color.red('Failed to load Playwright. Please install "playwright" to use browser mode.'), error);
+        const providers = [
+            ...new Set(browserProjects.map((p)=>p.normalizedConfig.browser.provider))
+        ];
+        logger.error(color.red(`Failed to initialize browser provider runtime (${providers.join(', ')}).`), error);
         throw error;
     }
     const { browser, port } = runtime;
-    const browserProjects = getBrowserProjects(context);
     const projectRuntimeConfigs = browserProjects.map((project)=>({
             name: project.name,
             environmentName: project.environmentName,
@@ -2644,7 +4231,7 @@ const listBrowserTests = async (context, options)=>{
         viewport: null
     });
     const page = await browserContext.newPage();
-    await page.exposeFunction('__rstest_dispatch__', (message)=>{
+    await page.exposeFunction(DISPATCH_MESSAGE_TYPE, (message)=>{
         switch(message.type){
             case 'collect-result':
                 {
@@ -2726,99 +4313,6 @@ const listBrowserTests = async (context, options)=>{
         close: cleanup
     };
 };
-const BROWSER_VIEWPORT_PRESET_IDS = [
-    'iPhoneSE',
-    'iPhoneXR',
-    'iPhone12Pro',
-    'iPhone14ProMax',
-    'Pixel7',
-    'SamsungGalaxyS8Plus',
-    'SamsungGalaxyS20Ultra',
-    'iPadMini',
-    'iPadAir',
-    'iPadPro',
-    'SurfacePro7',
-    'SurfaceDuo',
-    'GalaxyZFold5',
-    'AsusZenbookFold',
-    'SamsungGalaxyA51A71',
-    'NestHub',
-    'NestHubMax'
-];
-const BROWSER_VIEWPORT_PRESET_DIMENSIONS = {
-    iPhoneSE: {
-        width: 375,
-        height: 667
-    },
-    iPhoneXR: {
-        width: 414,
-        height: 896
-    },
-    iPhone12Pro: {
-        width: 390,
-        height: 844
-    },
-    iPhone14ProMax: {
-        width: 430,
-        height: 932
-    },
-    Pixel7: {
-        width: 412,
-        height: 915
-    },
-    SamsungGalaxyS8Plus: {
-        width: 360,
-        height: 740
-    },
-    SamsungGalaxyS20Ultra: {
-        width: 412,
-        height: 915
-    },
-    iPadMini: {
-        width: 768,
-        height: 1024
-    },
-    iPadAir: {
-        width: 820,
-        height: 1180
-    },
-    iPadPro: {
-        width: 1024,
-        height: 1366
-    },
-    SurfacePro7: {
-        width: 912,
-        height: 1368
-    },
-    SurfaceDuo: {
-        width: 540,
-        height: 720
-    },
-    GalaxyZFold5: {
-        width: 344,
-        height: 882
-    },
-    AsusZenbookFold: {
-        width: 853,
-        height: 1280
-    },
-    SamsungGalaxyA51A71: {
-        width: 412,
-        height: 914
-    },
-    NestHub: {
-        width: 1024,
-        height: 600
-    },
-    NestHubMax: {
-        width: 1280,
-        height: 800
-    }
-};
-const resolveBrowserViewportPreset = (presetId)=>{
-    const size = BROWSER_VIEWPORT_PRESET_DIMENSIONS[presetId];
-    return size ?? null;
-};
 const SUPPORTED_PROVIDERS = [
     'playwright'
 ];