@rstest/browser 0.11.1 → 0.11.3

package/dist/index.js

@@ -1,10 +1,10 @@
+import { DEFAULT_TEST_TIMEOUT, PhaseTracker, RSTEST_ENV_SYMBOL_KEY, applyWebMockRspackConfig, browserIgnoredRuntimeConfigKeys, buildBrowserCoverageMap, color, createCoverageProvider, createRunnerEventSink, createSilentConsoleController, getNoTestFilesMessage, getNumCpus as browser_getNumCpus, getPrettyConsoleName, getSetupFiles, getTestEntries, hasUserRstestConfigPlugins, importMetaRstestDefine, initModifyRstestConfigHooks, isDebug, isTTY, loadCoverageProvider, logger, pluginMockRuntime, prepareWatchRerunState, projectRuntimeConfig, resolveProjectBuildCache, resolveShardedEntries, resolveSnapshotPathDefault, resolveWorkerCount, rsbuild, serializableConfig } from "@rstest/core/internal/browser";
 import { existsSync } from "node:fs";
 import promises from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
-import { DEFAULT_TEST_TIMEOUT, PhaseTracker, RSTEST_ENV_SYMBOL_KEY, color, createCoverageProvider, getNoTestFilesMessage, getNumCpus, getSetupFiles, getTestEntries, isDebug, isTTY, loadCoverageProvider, logger, parseWorkers, resolveProjectBuildCache, rsbuild, serializableConfig } from "@rstest/core/internal/browser";
 import open_editor from "open-editor";
-import { basename, dirname, join, normalize, relative, resolve as external_pathe_resolve } from "pathe";
+import { dirname, join, normalize, relative, resolve as external_pathe_resolve } from "pathe";
 import sirv from "sirv";
 import { WebSocketServer } from "ws";
 import convert_source_map from "convert-source-map";
@@ -1654,113 +1654,6 @@ __webpack_require__.add({
         };
     }
 });
-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'
-];
-const isPlainObject = (value)=>'[object Object]' === Object.prototype.toString.call(value);
-const validateViewport = (viewport)=>{
-    if (null == viewport) return;
-    if ('string' == typeof viewport) {
-        const presetId = viewport.trim();
-        if (!presetId) throw new Error('browser.viewport must be a non-empty preset id.');
-        if (!resolveBrowserViewportPreset(presetId)) throw new Error(`browser.viewport must be a valid preset id. Received: ${viewport}`);
-        return;
-    }
-    if (isPlainObject(viewport)) {
-        const width = viewport.width;
-        const height = viewport.height;
-        if (!Number.isFinite(width) || width <= 0) throw new Error('browser.viewport.width must be a positive number.');
-        if (!Number.isFinite(height) || height <= 0) throw new Error('browser.viewport.height must be a positive number.');
-        return;
-    }
-    throw new Error('browser.viewport must be either a preset id or { width, height }.');
-};
-const validateBrowserConfig = (context)=>{
-    for (const project of context.projects){
-        const { browser, output } = project.normalizedConfig;
-        if (browser.enabled) {
-            if (!browser.provider) throw new Error('browser.provider is required when browser.enabled is true.');
-            if (!SUPPORTED_PROVIDERS.includes(browser.provider)) throw new Error(`browser.provider must be one of: ${SUPPORTED_PROVIDERS.join(', ')}.`);
-            validateViewport(browser.viewport);
-            if (!isPlainObject(browser.providerOptions)) throw new Error('browser.providerOptions must be a plain object.');
-            if (output?.bundleDependencies === false) throw new Error('output.bundleDependencies false is not supported in browser mode.');
-        }
-    }
-};
 const TYPE_REQUEST = "q";
 const TYPE_RESPONSE = "s";
 function createPromiseWithResolvers() {
@@ -1957,16 +1850,22 @@ function createBirpc($functions, options) {
     return rpc;
 }
 const DEFAULT_MAX_HEADLESS_WORKERS = 12;
-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 resolveHeadlessWorkerCount = ({ command, maxWorkers, totalTasks, numCpus = browser_getNumCpus() })=>{
+    const base = Math.max(Math.min(DEFAULT_MAX_HEADLESS_WORKERS, numCpus - 1), 1);
+    return resolveWorkerCount({
+        command,
+        maxWorkers,
+        totalTasks,
+        recommended: base,
+        watchRecommended: Math.max(Math.floor(base / 2), 1),
+        numCpus
+    });
 };
+const getHeadlessConcurrency = (context, totalTests)=>resolveHeadlessWorkerCount({
+        command: context.command,
+        maxWorkers: context.normalizedConfig.pool.maxWorkers,
+        totalTasks: totalTests
+    });
 const toErrorMessage = (error)=>error instanceof Error ? error.message : String(error);
 class HostDispatchRouter {
     handlers = new Map();
@@ -2071,6 +1970,172 @@ const createHostDispatchRouter = ({ routerOptions, runnerCallbacks, runSnapshotR
     }
     return router;
 };
+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 ignoredKeyWarnings = {
+    testEnvironment: {
+        isNonDefault: (config)=>'node' !== config.testEnvironment.name,
+        message: (config)=>`Ignoring testEnvironment '${config.testEnvironment.name}' in browser mode: the browser itself is the test environment.`
+    },
+    isolate: {
+        isNonDefault: (config)=>false === config.isolate,
+        message: ()=>"Ignoring isolate: false in browser mode: each test file still runs in a fresh context.",
+        browserOnly: true
+    },
+    detectAsyncLeaks: {
+        isNonDefault: (config)=>true === config.detectAsyncLeaks,
+        message: ()=>"Ignoring detectAsyncLeaks in browser mode: it relies on node async_hooks."
+    },
+    logHeapUsage: {
+        isNonDefault: (config)=>true === config.logHeapUsage,
+        message: ()=>'Ignoring logHeapUsage in browser mode.'
+    }
+};
+const speciallyHandledIgnoredKeys = [
+    'coverage'
+];
+const browserValidatedIgnoredKeys = [
+    ...Object.keys(ignoredKeyWarnings),
+    ...speciallyHandledIgnoredKeys
+];
+const assertIgnoredKeysCovered = ()=>{
+    const covered = new Set(browserValidatedIgnoredKeys);
+    const uncovered = browserIgnoredRuntimeConfigKeys.filter((key)=>!covered.has(key));
+    if (uncovered.length > 0) throw new Error(`Browser config validation is out of sync with executorCapabilities: no check for ignored RuntimeConfig field(s): ${uncovered.join(', ')}. Add a descriptor to \`ignoredKeyWarnings\` or \`speciallyHandledIgnoredKeys\`.`);
+};
+assertIgnoredKeysCovered();
+const SUPPORTED_PROVIDERS = [
+    'playwright'
+];
+const isPlainObject = (value)=>'[object Object]' === Object.prototype.toString.call(value);
+const validateViewport = (viewport)=>{
+    if (null == viewport) return;
+    if ('string' == typeof viewport) {
+        const presetId = viewport.trim();
+        if (!presetId) throw new Error('browser.viewport must be a non-empty preset id.');
+        if (!resolveBrowserViewportPreset(presetId)) throw new Error(`browser.viewport must be a valid preset id. Received: ${viewport}`);
+        return;
+    }
+    if (isPlainObject(viewport)) {
+        const width = viewport.width;
+        const height = viewport.height;
+        if (!Number.isFinite(width) || width <= 0) throw new Error('browser.viewport.width must be a positive number.');
+        if (!Number.isFinite(height) || height <= 0) throw new Error('browser.viewport.height must be a positive number.');
+        return;
+    }
+    throw new Error('browser.viewport must be either a preset id or { width, height }.');
+};
+const reportUnsupportedBrowserOptions = (context)=>{
+    const browserProjects = context.projects.filter((project)=>project.normalizedConfig.browser.enabled);
+    if (0 === browserProjects.length) return;
+    const isBrowserOnlyRun = browserProjects.length === context.projects.length;
+    const globalConfig = context.normalizedConfig;
+    const { coverage } = globalConfig;
+    if ('list' !== context.command && coverage.enabled && 'v8' === coverage.provider) {
+        if (isBrowserOnlyRun) throw new Error("Coverage provider 'v8' is not supported in browser mode: browser projects produce no v8 coverage. Use the default istanbul provider (coverage.provider: 'istanbul') for browser coverage.");
+        logger.warn(color.yellow("Coverage provider 'v8' produces no coverage for browser project files; use the 'istanbul' provider to collect browser coverage. Node projects will still use v8."));
+    }
+    const warnings = new Set();
+    if ('forks' !== globalConfig.pool.type) warnings.add(`Ignoring pool.type '${globalConfig.pool.type}' in browser mode.`);
+    if (globalConfig.pool.execArgv && globalConfig.pool.execArgv.length > 0) warnings.add('Ignoring pool.execArgv in browser mode.');
+    for (const project of browserProjects){
+        const config = project.normalizedConfig;
+        for (const key of browserIgnoredRuntimeConfigKeys){
+            const descriptor = ignoredKeyWarnings[key];
+            if (descriptor) {
+                if (!descriptor.browserOnly || isBrowserOnlyRun) {
+                    if (descriptor.isNonDefault(config)) warnings.add(descriptor.message(config));
+                }
+            }
+        }
+    }
+    for (const message of warnings)logger.warn(color.yellow(message));
+};
+const validateBrowserConfig = (context)=>{
+    for (const project of context.projects){
+        const { browser, output } = project.normalizedConfig;
+        if (browser.enabled) {
+            if (!browser.provider) throw new Error('browser.provider is required when browser.enabled is true.');
+            if (!SUPPORTED_PROVIDERS.includes(browser.provider)) throw new Error(`browser.provider must be one of: ${SUPPORTED_PROVIDERS.join(', ')}.`);
+            validateViewport(browser.viewport);
+            if (!isPlainObject(browser.providerOptions)) throw new Error('browser.providerOptions must be a plain object.');
+            if (output?.bundleDependencies === false) throw new Error('output.bundleDependencies false is not supported in browser mode.');
+        }
+    }
+    reportUnsupportedBrowserOptions(context);
+};
 const createHeadedSerialTaskQueue = ()=>{
     let queue = Promise.resolve();
     const enqueue = (task)=>{
@@ -2846,7 +2911,6 @@ const getBrowserProviderOptions = (project)=>{
     return browserConfig.providerOptions ?? {};
 };
 const getFileTaskId = (testPath)=>`file:${testPath}`;
-const getBufferedLogTaskId = (log)=>log.taskId ?? getFileTaskId(log.testPath);
 const createDeferredPromise = ()=>{
     let resolve;
     let reject;
@@ -3158,41 +3222,12 @@ const getAffectedTestFiles = (chunks, entryTestFiles)=>{
     watchContext.chunkHashes = currentHashes;
     return Array.from(affectedFiles);
 };
-const getRuntimeConfigFromProject = (project)=>{
-    const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate, coverage, snapshotFormat, env, bail, logHeapUsage, detectAsyncLeaks, chaiConfig, includeTaskLocation, silent } = project.normalizedConfig;
-    return {
-        env: {
-            NODE_ENV: process.env.NODE_ENV,
-            RSTEST: 'true',
-            ...env
-        },
-        testNamePattern,
-        testTimeout,
-        hookTimeout,
-        passWithNoTests,
-        retry,
-        globals,
-        clearMocks,
-        resetMocks,
-        restoreMocks,
-        unstubEnvs,
-        unstubGlobals,
-        maxConcurrency,
-        printConsoleTrace,
-        disableConsoleIntercept,
-        testEnvironment,
-        isolate,
-        coverage,
-        snapshotFormat,
-        bail,
-        logHeapUsage,
-        detectAsyncLeaks,
-        chaiConfig,
-        includeTaskLocation,
-        silent
-    };
-};
 const getBrowserProjects = (context)=>context.projects.filter((project)=>project.normalizedConfig.browser.enabled);
+const getBrowserRsbuildEnvironmentConfig = (project)=>({
+        plugins: project.normalizedConfig.plugins,
+        root: project.rootPath
+    });
+const getMaxTestTimeoutForRpc = (projects)=>Math.max(...projects.map((p)=>p.normalizedConfig.testTimeout ?? DEFAULT_TEST_TIMEOUT));
 const getBrowserLaunchOptions = (project)=>({
         provider: project.normalizedConfig.browser.provider,
         browser: project.normalizedConfig.browser.browser,
@@ -3219,9 +3254,7 @@ const resolveProviderForTestPath = ({ testPath, browserProjects })=>{
     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 browserProjects = getBrowserProjects(context);
-    return Promise.all(browserProjects.map(async (project)=>{
+const collectProjectEntries = async (context, browserProjects = getBrowserProjects(context))=>Promise.all(browserProjects.map(async (project)=>{
         const { normalizedConfig: { include, exclude, includeSource, setupFiles } } = project;
         const tests = await getTestEntries({
             include,
@@ -3239,7 +3272,6 @@ const collectProjectEntries = async (context)=>{
             testFiles: Object.values(tests)
         };
     }));
-};
 const resolveBrowserFile = (relativePath)=>{
     const candidates = [
         external_pathe_resolve(hostController_dirname, '../src', relativePath),
@@ -3300,12 +3332,29 @@ const generateManifestModule = ({ manifestPath, entries, isWatchMode })=>{
         if (isWatchMode) {
             const includeRegExp = globPatternsToRegExp(project.normalizedConfig.include);
             const excludeRegExp = createBrowserContextExcludeRegExp(project.normalizedConfig.exclude.patterns, projectRootPosix);
-            lines.push(`const ${varName} = import.meta.webpackContext(${JSON.stringify(projectRootPosix)}, {`);
-            lines.push('  recursive: true,');
-            lines.push(`  regExp: ${includeRegExp.toString()},`);
-            if (excludeRegExp) lines.push(`  exclude: ${excludeRegExp.toString()},`);
-            lines.push("  mode: 'lazy',");
-            lines.push('});');
+            const { includeSource } = project.normalizedConfig;
+            const emitContext = (contextVarName, regExp)=>{
+                lines.push(`const ${contextVarName} = import.meta.webpackContext(${JSON.stringify(projectRootPosix)}, {`);
+                lines.push('  recursive: true,');
+                lines.push(`  regExp: ${regExp.toString()},`);
+                if (excludeRegExp) lines.push(`  exclude: ${excludeRegExp.toString()},`);
+                lines.push("  mode: 'lazy',");
+                lines.push('});');
+            };
+            if (0 === includeSource.length) emitContext(varName, includeRegExp);
+            else {
+                emitContext(`${varName}_include`, includeRegExp);
+                emitContext(`${varName}_source`, globPatternsToRegExp(includeSource));
+                const probedKeys = testFiles.map((filePath)=>toContextKey(filePath, projectRootPosix));
+                lines.push(`const ${varName}_probed = ${JSON.stringify(probedKeys)};`);
+                lines.push(`const ${varName}_includeKeys = new Set(${varName}_include.keys());`);
+                lines.push(`const ${varName} = Object.assign(`);
+                lines.push(`  (key) => ${varName}_includeKeys.has(key) ? ${varName}_include(key) : ${varName}_source(key),`);
+                lines.push('  {');
+                lines.push(`    keys: () => Array.from(new Set([...${varName}_includeKeys, ...${varName}_probed])),`);
+                lines.push('  },');
+                lines.push(');');
+            }
         } else {
             lines.push(`const ${varName}_modules = {`);
             for (const filePath of testFiles){
@@ -3399,7 +3448,7 @@ const registerWatchCleanup = ()=>{
     });
     watchContext.cleanupRegistered = true;
 };
-const createBrowserRuntime = async ({ context, projectEntries, tempDir, isWatchMode, onTriggerRerun, containerDistPath, containerDevServer, forceHeadless })=>{
+const createBrowserRuntime = async ({ context, projectEntries: initialProjectEntries, browserProjects, shardedEntries, freezeShardedEntries, tempDir, isWatchMode, onTriggerRerun, containerDistPath, containerDevServer, forceHeadless, skipProviderLaunch, appliedModifyRstestConfigEnvironments })=>{
     const containerHtmlTemplate = containerDistPath ? await promises.readFile(join(containerDistPath, 'index.html'), 'utf-8') : null;
     let injectedContainerHtml = null;
     let serializedOptions = 'null';
@@ -3408,11 +3457,59 @@ const createBrowserRuntime = async ({ context, projectEntries, tempDir, isWatchM
         serializedOptions = serializeForInlineScript(options);
         if (containerHtmlTemplate) injectedContainerHtml = containerHtmlTemplate.replace(OPTIONS_PLACEHOLDER, serializedOptions);
     };
-    const browserProjects = getBrowserProjects(context);
-    const browserLaunchOptions = ensureConsistentBrowserLaunchOptions(browserProjects);
+    let browserLaunchOptions = ensureConsistentBrowserLaunchOptions(browserProjects);
+    let projectEntries = initialProjectEntries;
+    const manifestModules = [];
+    const createRuntimeWithoutProvider = ()=>{
+        const firstProject = browserProjects[0];
+        return {
+            projectServers: new Map(),
+            containerServer: {
+                projectName: firstProject.name,
+                environmentName: firstProject.environmentName,
+                rsbuildInstance: void 0,
+                devServer: {
+                    close: async ()=>void 0
+                },
+                port: 0,
+                manifestPath: ''
+            },
+            browser: void 0,
+            browserLaunchOptions,
+            wsPort: 0,
+            tempDir,
+            setContainerOptions,
+            dispatchHandlers,
+            wss: void 0,
+            projectEntries
+        };
+    };
+    const getProjectEntry = (project)=>projectEntries.find((item)=>item.project.environmentName === project.environmentName);
+    const refreshManifestModule = (manifestModule)=>{
+        const entry = getProjectEntry(manifestModule.project);
+        manifestModule.modules[manifestModule.manifestPath] = generateManifestModule({
+            manifestPath: manifestModule.manifestPath,
+            entries: [
+                {
+                    project: manifestModule.project,
+                    testFiles: entry?.testFiles ?? [],
+                    setupFiles: entry?.setupFiles ?? []
+                }
+            ],
+            isWatchMode
+        });
+    };
+    const refreshProjectEntries = async ()=>{
+        validateBrowserConfig(context);
+        browserLaunchOptions = ensureConsistentBrowserLaunchOptions(browserProjects);
+        const updatedShardedEntries = freezeShardedEntries ? shardedEntries : context.normalizedConfig.shard ? await resolveShardedEntries(context, {
+            silent: true
+        }) : shardedEntries;
+        projectEntries = await resolveProjectEntries(context, updatedShardedEntries, browserProjects);
+        for (const manifestModule of manifestModules)refreshManifestModule(manifestModule);
+    };
     const browserRuntimePath = fileURLToPath(import.meta.resolve('@rstest/core/internal/browser-runtime'));
     const staticRstestAliases = {
-        '@rstest/core': resolveBrowserFile('client/public.ts'),
         '@rstest/browser': resolveBrowserFile('browser.ts'),
         '@rstest/core/internal/browser-runtime': browserRuntimePath
     };
@@ -3454,26 +3551,27 @@ const createBrowserRuntime = async ({ context, projectEntries, tempDir, isWatchM
             return false;
         }
     };
-    const entryByEnvironmentName = new Map(projectEntries.map((entry)=>[
-            entry.project.environmentName,
-            entry
-        ]));
     const buildProjectServer = async (project, isContainerServer)=>{
         const manifestPath = join(tempDir, toSafeVarName(project.environmentName), VIRTUAL_MANIFEST_FILENAME);
-        const entry = entryByEnvironmentName.get(project.environmentName);
-        const manifestSource = generateManifestModule({
+        const entry = getProjectEntry(project);
+        const virtualManifestModules = {
+            [manifestPath]: generateManifestModule({
+                manifestPath,
+                entries: [
+                    {
+                        project,
+                        testFiles: entry?.testFiles ?? [],
+                        setupFiles: entry?.setupFiles ?? []
+                    }
+                ],
+                isWatchMode
+            })
+        };
+        const virtualManifestPlugin = new rspack.experiments.VirtualModulesPlugin(virtualManifestModules);
+        manifestModules.push({
             manifestPath,
-            entries: [
-                {
-                    project,
-                    testFiles: entry?.testFiles ?? [],
-                    setupFiles: entry?.setupFiles ?? []
-                }
-            ],
-            isWatchMode
-        });
-        const virtualManifestPlugin = new rspack.experiments.VirtualModulesPlugin({
-            [manifestPath]: manifestSource
+            project,
+            modules: virtualManifestModules
         });
         const rstestInternalAliases = {
             '@rstest/browser-manifest': manifestPath,
@@ -3482,11 +3580,10 @@ const createBrowserRuntime = async ({ context, projectEntries, tempDir, isWatchM
         const isHeadless = forceHeadless || project.normalizedConfig.browser.headless;
         const enableHmr = shouldEnableBrowserHmr(isWatchMode, isHeadless);
         const rsbuildInstance = await createRsbuild({
-            callerName: 'rstest-browser',
+            callerName: 'rstest',
             rsbuildConfig: {
                 root: context.rootPath,
                 mode: 'development',
-                plugins: project.normalizedConfig.plugins || [],
                 server: {
                     printUrls: false,
                     port: project.normalizedConfig.browser.port ?? (isContainerServer ? 4000 : 0),
@@ -3494,11 +3591,21 @@ const createBrowserRuntime = async ({ context, projectEntries, tempDir, isWatchM
                 },
                 dev: createBrowserRsbuildDevConfig(enableHmr),
                 environments: {
-                    [project.environmentName]: {}
+                    [project.environmentName]: getBrowserRsbuildEnvironmentConfig(project)
                 }
             }
         });
+        initModifyRstestConfigHooks(context, rsbuildInstance, [
+            project
+        ], [
+            project
+        ], {
+            getEnvironmentConfig: getBrowserRsbuildEnvironmentConfig,
+            onModifyRstestConfigApplied: refreshProjectEntries,
+            appliedEnvironmentNames: appliedModifyRstestConfigEnvironments
+        });
         rsbuildInstance.addPlugins([
+            pluginMockRuntime,
             {
                 name: 'rstest:browser-user-config',
                 setup (api) {
@@ -3529,7 +3636,8 @@ const createBrowserRuntime = async ({ context, projectEntries, tempDir, isWatchM
                                 source: {
                                     define: {
                                         'process.env': rstestEnvDefine,
-                                        'import.meta.env': rstestEnvDefine
+                                        'import.meta.env': rstestEnvDefine,
+                                        'import.meta.rstest': importMetaRstestDefine('web')
                                     }
                                 },
                                 output: {
@@ -3541,6 +3649,10 @@ const createBrowserRuntime = async ({ context, projectEntries, tempDir, isWatchM
                                 tools: {
                                     rspack: (rspackConfig)=>{
                                         rspackConfig.mode = 'development';
+                                        applyWebMockRspackConfig(rspackConfig, {
+                                            rspack: rspack,
+                                            rootPath: project.rootPath
+                                        });
                                         rspackConfig.lazyCompilation = enableHmr ? createBrowserLazyCompilationConfig(setupFiles) : false;
                                         rspackConfig.plugins = rspackConfig.plugins || [];
                                         rspackConfig.plugins.push(virtualManifestPlugin);
@@ -3593,6 +3705,21 @@ const createBrowserRuntime = async ({ context, projectEntries, tempDir, isWatchM
                 }
             }
         ]);
+        if (skipProviderLaunch) {
+            await rsbuildInstance.initConfigs({
+                action: 'dev'
+            });
+            return {
+                projectName: project.name,
+                environmentName: project.environmentName,
+                rsbuildInstance,
+                devServer: {
+                    close: async ()=>void 0
+                },
+                port: 0,
+                manifestPath
+            };
+        }
         const coverage = project.normalizedConfig.coverage;
         if (coverage?.enabled && 'list' !== context.command) {
             const { pluginCoverage } = await loadCoverageProvider(coverage, context.rootPath);
@@ -3688,6 +3815,7 @@ const createBrowserRuntime = async ({ context, projectEntries, tempDir, isWatchM
         await closeAllProjectServers(projectServers.values());
         throw error;
     }
+    if (skipProviderLaunch) return createRuntimeWithoutProvider();
     const containerServer = projectServers.get(browserProjects[0].name);
     const wss = new WebSocketServer({
         port: 0
@@ -3715,7 +3843,8 @@ const createBrowserRuntime = async ({ context, projectEntries, tempDir, isWatchM
             tempDir,
             setContainerOptions,
             dispatchHandlers,
-            wss
+            wss,
+            projectEntries
         };
     } catch (error) {
         wss.close();
@@ -3723,9 +3852,8 @@ const createBrowserRuntime = async ({ context, projectEntries, tempDir, isWatchM
         throw error;
     }
 };
-async function resolveProjectEntries(context, shardedEntries) {
+async function resolveProjectEntries(context, shardedEntries, browserProjects) {
     if (shardedEntries) {
-        const browserProjects = getBrowserProjects(context);
         const projectEntries = [];
         for (const project of browserProjects){
             const entryInfo = shardedEntries.get(project.environmentName);
@@ -3740,14 +3868,14 @@ async function resolveProjectEntries(context, shardedEntries) {
         }
         return projectEntries;
     }
-    return collectProjectEntries(context);
+    return collectProjectEntries(context, browserProjects);
 }
 const runBrowserController = async (context, options)=>{
-    const { skipOnTestRunEnd = false, allowEmptyWatchRun = false, onTraceEvents } = options ?? {};
+    const { allowEmptyWatchRun = false, allowEmptyRun = false, filesOnly = false, onTraceEvents, env } = options ?? {};
     const buildStart = Date.now();
     const isWatchMode = 'watch' === context.command;
     const phaseTrackers = onTraceEvents ? new Map() : void 0;
-    const browserProjects = getBrowserProjects(context);
+    const browserProjects = options?.projects ?? getBrowserProjects(context);
     const useHeadlessDirect = browserProjects.every((project)=>project.normalizedConfig.browser.headless);
     const browserSourceMapCache = new Map();
     const isHttpLikeFile = (file)=>/^https?:\/\//.test(file);
@@ -3795,7 +3923,7 @@ const runBrowserController = async (context, options)=>{
             resolveSourcemap: resolveBrowserSourcemap,
             close
         };
-        if (!skipOnTestRunEnd) for (const reporter of context.reporters)await reporter.onTestRunEnd?.({
+        if (isWatchMode) for (const reporter of context.reporters)await reporter.onTestRunEnd?.({
             results: [],
             testResults: [],
             duration: errorResult.duration,
@@ -3807,9 +3935,9 @@ const runBrowserController = async (context, options)=>{
     };
     const toError = (error)=>error instanceof Error ? error : new Error(String(error));
     const failWithError = async (error, cleanup)=>{
-        ensureProcessExitCode(1);
+        if (isWatchMode) ensureProcessExitCode(1);
         const normalizedError = toError(error);
-        if (cleanup && skipOnTestRunEnd) return buildErrorResult(normalizedError, cleanup);
+        if (cleanup && !isWatchMode) return buildErrorResult(normalizedError, cleanup);
         try {
             return await buildErrorResult(normalizedError);
         } finally{
@@ -3821,13 +3949,13 @@ const runBrowserController = async (context, options)=>{
         return previous.map((file)=>file.testPath).filter((testPath)=>!currentPathSet.has(testPath));
     };
     const notifyTestRunStart = async ()=>{
-        if (skipOnTestRunEnd) return;
+        if (!isWatchMode) return;
         for (const reporter of context.reporters)await reporter.onTestRunStart?.();
     };
     const coverageConfig = browserProjects.find((project)=>project.normalizedConfig.coverage?.enabled)?.normalizedConfig.coverage;
     const coverageProvider = coverageConfig?.enabled ? await createCoverageProvider(coverageConfig, context.rootPath) : null;
     const notifyTestRunEnd = async ({ duration, unhandledErrors, filterRerunTestPaths })=>{
-        if (skipOnTestRunEnd) return;
+        if (!isWatchMode) return;
         let mergedCoverage;
         if (coverageProvider) {
             const coverageMap = coverageProvider.createCoverageMap();
@@ -3867,12 +3995,28 @@ const runBrowserController = async (context, options)=>{
             return failWithError(error);
         }
     }
-    const projectEntries = await resolveProjectEntries(context, options?.shardedEntries);
-    const totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
+    let projectEntries = await resolveProjectEntries(context, options?.shardedEntries, browserProjects);
+    let totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
     const shouldKeepWatchingWithEmptySet = isWatchMode && allowEmptyWatchRun;
-    if (0 === totalTests) {
+    const shouldInitializeEmptyBrowserHooks = 0 === totalTests && hasUserRstestConfigPlugins(browserProjects);
+    const createEmptyRunResult = ()=>{
+        const elapsed = Math.max(0, Date.now() - buildStart);
+        return {
+            results: [],
+            testResults: [],
+            duration: {
+                totalTime: elapsed,
+                buildTime: elapsed,
+                testTime: 0
+            },
+            hasFailure: false,
+            getSourcemap: getBrowserSourcemap,
+            resolveSourcemap: resolveBrowserSourcemap
+        };
+    };
+    const reportEmptyTestSet = ()=>{
         const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
-        if (!skipOnTestRunEnd) {
+        if (isWatchMode || !allowEmptyRun) {
             const message = shouldKeepWatchingWithEmptySet ? 'No test files found.' : getNoTestFilesMessage({
                 context,
                 code,
@@ -3883,10 +4027,13 @@ const runBrowserController = async (context, options)=>{
             if (context.relatedFilters?.length) logger.log(color.gray('related: '), context.relatedFilters.join(color.gray(', ')));
             else if (context.fileFilters?.length) logger.log(color.gray('filter: '), context.fileFilters.join(color.gray(', ')));
         }
-        if (0 !== code && !shouldKeepWatchingWithEmptySet) ensureProcessExitCode(code);
-        if (!shouldKeepWatchingWithEmptySet) return;
+        if (isWatchMode && 0 !== code && !shouldKeepWatchingWithEmptySet && !allowEmptyRun) ensureProcessExitCode(code);
+        return !shouldKeepWatchingWithEmptySet;
+    };
+    if (0 === totalTests && !shouldInitializeEmptyBrowserHooks) {
+        if (reportEmptyTestSet()) return allowEmptyRun ? createEmptyRunResult() : void 0;
     }
-    await notifyTestRunStart();
+    if (!filesOnly) await notifyTestRunStart();
     const enableCliShortcuts = isWatchMode && isBrowserWatchCliShortcutsEnabled();
     const browserTempOutputRoot = context.normalizedConfig.output.distPath.root;
     const tempDir = isWatchMode && watchContext.runtime ? watchContext.runtime.tempDir : isWatchMode ? join(context.rootPath, browserTempOutputRoot, 'browser', 'watch') : join(context.rootPath, browserTempOutputRoot, 'browser', Date.now().toString());
@@ -3898,13 +4045,18 @@ const runBrowserController = async (context, options)=>{
             runtime = await createBrowserRuntime({
                 context,
                 projectEntries,
+                browserProjects,
+                shardedEntries: options?.shardedEntries,
+                freezeShardedEntries: options?.freezeShardedEntries,
                 tempDir,
                 isWatchMode,
                 onTriggerRerun: isWatchMode ? async ()=>{
                     await triggerRerun?.();
                 } : void 0,
                 containerDistPath,
-                containerDevServer
+                containerDevServer,
+                skipProviderLaunch: filesOnly,
+                appliedModifyRstestConfigEnvironments: options?.appliedModifyRstestConfigEnvironments
             });
         } catch (error) {
             return failWithError(error, async ()=>{
@@ -3922,8 +4074,27 @@ const runBrowserController = async (context, options)=>{
             });
         }
     }
-    const { browser, browserLaunchOptions, wsPort, wss } = runtime;
+    projectEntries = runtime.projectEntries;
+    totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
     const buildTime = Date.now() - buildStart;
+    if (filesOnly) return {
+        results: [],
+        testResults: [],
+        duration: {
+            totalTime: buildTime,
+            buildTime,
+            testTime: 0
+        },
+        hasFailure: false,
+        getSourcemap: getBrowserSourcemap,
+        resolveSourcemap: resolveBrowserSourcemap,
+        close: ()=>destroyBrowserRuntime(runtime)
+    };
+    if (0 === totalTests && reportEmptyTestSet()) {
+        await destroyBrowserRuntime(runtime);
+        return allowEmptyRun ? createEmptyRunResult() : void 0;
+    }
+    const { browser, browserLaunchOptions, wsPort, wss } = runtime;
     const allTestFiles = projectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
                 testPath: normalize(testPath),
                 projectName: entry.project.name
@@ -3932,10 +4103,13 @@ const runBrowserController = async (context, options)=>{
             name: project.name,
             environmentName: project.environmentName,
             projectRoot: normalize(project.rootPath),
-            runtimeConfig: serializableConfig(getRuntimeConfigFromProject(project)),
+            runtimeConfig: serializableConfig(projectRuntimeConfig(project, {
+                envMode: 'static',
+                envOverlay: env
+            })),
             viewport: project.normalizedConfig.browser.viewport
         }));
-    const maxTestTimeoutForRpc = Math.max(...browserProjects.map((p)=>p.normalizedConfig.testTimeout ?? DEFAULT_TEST_TIMEOUT));
+    const maxTestTimeoutForRpc = getMaxTestTimeoutForRpc(browserProjects);
     const projectRunnerUrls = Object.fromEntries([
         ...runtime.projectServers
     ].map(([name, server])=>[
@@ -3996,11 +4170,28 @@ const runBrowserController = async (context, options)=>{
     const reporterResults = [];
     const caseResults = [];
     let fatalError = null;
+    const runnerSinks = new Map(browserProjects.map((project)=>[
+            project.name,
+            createRunnerEventSink(context, project.normalizedConfig)
+        ]));
+    const firstBrowserSink = runnerSinks.get(browserProjects[0].name);
+    const projectNameByTestPath = new Map();
+    const sinkForProjectName = (projectName)=>runnerSinks.get(projectName) ?? firstBrowserSink;
+    const sinkForTestPath = (testPath)=>{
+        const projectName = projectNameByTestPath.get(testPath);
+        return projectName ? sinkForProjectName(projectName) : firstBrowserSink;
+    };
+    const silentConsoleController = createSilentConsoleController({
+        runtimeConfig: {
+            silent: context.normalizedConfig.silent,
+            disableConsoleIntercept: context.normalizedConfig.disableConsoleIntercept
+        },
+        emitInterceptedLog: (log)=>sinkForTestPath(log.testPath).onConsoleLog(log),
+        writeOriginalLog: ()=>{}
+    });
     const snapshotRpcMethods = {
         async resolveSnapshotPath (testPath) {
-            const snapExtension = '.snap';
-            const resolver = context.normalizedConfig.resolveSnapshotPath || (()=>join(dirname(testPath), '__snapshots__', `${basename(testPath)}${snapExtension}`));
-            return resolver(testPath, snapExtension);
+            return resolveSnapshotPathDefault(testPath, context.normalizedConfig.resolveSnapshotPath);
         },
         async readSnapshotFile (filepath) {
             try {
@@ -4023,6 +4214,7 @@ const runBrowserController = async (context, options)=>{
         }
     };
     const handleTestFileStart = async (payload)=>{
+        projectNameByTestPath.set(payload.testPath, payload.projectName);
         if (phaseTrackers) {
             const tracker = new PhaseTracker({
                 trace: {
@@ -4034,24 +4226,24 @@ const runBrowserController = async (context, options)=>{
             tracker.transition('prepare');
             phaseTrackers.set(payload.testPath, tracker);
         }
-        await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileStart?.({
-                testId: getFileTaskId(payload.testPath),
-                testPath: payload.testPath,
-                tests: []
-            })));
+        await sinkForProjectName(payload.projectName).onTestFileStart({
+            testId: getFileTaskId(payload.testPath),
+            testPath: payload.testPath,
+            tests: []
+        });
     };
     const handleTestFileReady = async (payload)=>{
         phaseTrackers?.get(payload.testPath)?.transition('tests');
-        await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileReady?.(payload)));
+        await sinkForTestPath(payload.testPath).onTestFileReady(payload);
     };
     const handleTestSuiteStart = async (payload)=>{
         phaseTrackers?.get(payload.testPath)?.recordSuiteStart(payload);
-        await Promise.all(context.reporters.map((reporter)=>reporter.onTestSuiteStart?.(payload)));
+        await sinkForTestPath(payload.testPath).onTestSuiteStart(payload);
     };
     const handleTestSuiteResult = async (payload)=>{
         phaseTrackers?.get(payload.testPath)?.recordSuiteResult(payload);
-        await Promise.all(context.reporters.map((reporter)=>reporter.onTestSuiteResult?.(payload)));
-        if ('passed-only' === context.normalizedConfig.silent) await flushBufferedLogsForTask({
+        await sinkForTestPath(payload.testPath).onTestSuiteResult(payload);
+        if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
             taskId: payload.testId,
             status: payload.status,
             taskParentNames: payload.parentNames,
@@ -4061,13 +4253,13 @@ const runBrowserController = async (context, options)=>{
     };
     const handleTestCaseStart = async (payload)=>{
         phaseTrackers?.get(payload.testPath)?.recordCaseStart(payload);
-        await Promise.all(context.reporters.map((reporter)=>reporter.onTestCaseStart?.(payload)));
+        sinkForTestPath(payload.testPath).onTestCaseStart(payload);
     };
     const handleTestCaseResult = async (payload)=>{
         caseResults.push(payload);
         phaseTrackers?.get(payload.testPath)?.recordCaseResult(payload);
-        await Promise.all(context.reporters.map((reporter)=>reporter.onTestCaseResult?.(payload)));
-        if ('passed-only' === context.normalizedConfig.silent) await flushBufferedLogsForTask({
+        await sinkForTestPath(payload.testPath).onTestCaseResult(payload);
+        if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
             taskId: payload.testId,
             status: payload.status,
             taskParentNames: payload.parentNames,
@@ -4080,7 +4272,6 @@ const runBrowserController = async (context, options)=>{
         context.updateReporterResultState([
             payload
         ], payload.results);
-        if (payload.snapshotResult) context.snapshotManager.add(payload.snapshotResult);
         if (phaseTrackers) {
             const tracker = phaseTrackers.get(payload.testPath);
             if (tracker) {
@@ -4090,20 +4281,20 @@ const runBrowserController = async (context, options)=>{
                 phaseTrackers.delete(payload.testPath);
             }
         }
-        if ('passed-only' === context.normalizedConfig.silent) await flushBufferedLogsForTask({
+        if ('passed-only' === context.normalizedConfig.silent) silentConsoleController.flushBufferedLogsForTask({
             taskId: payload.testId,
             status: payload.status,
             taskParentNames: payload.parentNames,
             taskType: 'file',
             testPath: payload.testPath
         });
-        await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileResult?.(payload)));
-        if ('fail' === payload.status) ensureProcessExitCode(1);
+        await sinkForTestPath(payload.testPath).onTestFileResult(payload);
+        if (isWatchMode && 'fail' === payload.status) ensureProcessExitCode(1);
     };
     const handleLog = async (payload)=>{
         const log = {
             content: payload.content,
-            name: payload.level,
+            name: getPrettyConsoleName(payload.level),
             taskId: payload.taskId,
             taskName: payload.taskName,
             taskParentNames: payload.taskParentNames,
@@ -4112,62 +4303,13 @@ const runBrowserController = async (context, options)=>{
             type: payload.type,
             trace: payload.trace
         };
-        if (true === context.normalizedConfig.silent) return;
-        if ('passed-only' === context.normalizedConfig.silent) return void bufferConsoleLog(log);
-        if (context.normalizedConfig.disableConsoleIntercept) return;
-        await emitUserConsoleLog(log);
+        silentConsoleController.onConsoleLog(log);
     };
     const handleFatal = async (payload)=>{
         const error = new Error(payload.message);
         error.stack = payload.stack;
         fatalError = error;
-        ensureProcessExitCode(1);
-    };
-    const bufferedConsoleLogs = new Map();
-    const suiteIdsByChain = new Map();
-    const getSuiteChainKey = (names)=>names.join('\u0000');
-    const pushTaskId = (taskIds, taskId)=>{
-        if (!taskIds.includes(taskId)) taskIds.push(taskId);
-    };
-    const shouldEmitUserConsoleLog = (log)=>context.normalizedConfig.onConsoleLog?.(log.content, log.type) !== false;
-    const emitUserConsoleLog = async (log)=>{
-        if (!shouldEmitUserConsoleLog(log)) return;
-        await Promise.all(context.reporters.map((reporter)=>reporter.onUserConsoleLog?.(log)));
-    };
-    const bufferConsoleLog = (log)=>{
-        const taskId = getBufferedLogTaskId(log);
-        const logs = bufferedConsoleLogs.get(taskId) || [];
-        logs.push(log);
-        bufferedConsoleLogs.set(taskId, logs);
-        if ('suite' === log.taskType && log.taskId) suiteIdsByChain.set(getSuiteChainKey([
-            ...log.taskParentNames || [],
-            log.taskName || ''
-        ]), log.taskId);
-    };
-    const flushBufferedLogsForTask = async ({ taskId, status, taskParentNames, taskType, testPath })=>{
-        if ('fail' !== status) return void bufferedConsoleLogs.delete(taskId);
-        const taskIdsToFlush = [];
-        if ('case' === taskType) {
-            pushTaskId(taskIdsToFlush, getFileTaskId(testPath));
-            const suiteNames = taskParentNames || [];
-            for(let i = 0; i < suiteNames.length; i++){
-                const suiteId = suiteIdsByChain.get(getSuiteChainKey(suiteNames.slice(0, i + 1)));
-                if (suiteId) pushTaskId(taskIdsToFlush, suiteId);
-            }
-            pushTaskId(taskIdsToFlush, taskId);
-        }
-        if ('suite' === taskType) {
-            pushTaskId(taskIdsToFlush, getFileTaskId(testPath));
-            pushTaskId(taskIdsToFlush, taskId);
-        }
-        if ('file' === taskType) pushTaskId(taskIdsToFlush, taskId);
-        for (const bufferedTaskId of taskIdsToFlush){
-            const logs = bufferedConsoleLogs.get(bufferedTaskId);
-            if (logs) {
-                bufferedConsoleLogs.delete(bufferedTaskId);
-                for (const log of logs)await Promise.all(context.reporters.map((reporter)=>reporter.onUserConsoleLog?.(log)));
-            }
-        }
+        if (isWatchMode) ensureProcessExitCode(1);
     };
     const runSnapshotRpc = async (request)=>{
         switch(request.method){
@@ -4366,6 +4508,14 @@ const runBrowserController = async (context, options)=>{
                 await closeContextSafely(browserContext);
             }
         };
+        const makeSkippedFileResult = (file)=>({
+                testId: getFileTaskId(file.testPath),
+                status: 'skip',
+                name: '',
+                testPath: file.testPath,
+                project: file.projectName,
+                results: []
+            });
         const runFilesWithPool = async (files)=>{
             if (0 === files.length) return;
             const previous = runLifecycle.activeSession;
@@ -4378,8 +4528,17 @@ const runBrowserController = async (context, options)=>{
                 ...files
             ];
             const concurrency = getHeadlessConcurrency(context, queue.length);
+            const bail = context.normalizedConfig.bail;
             const worker = async ()=>{
                 while(queue.length > 0 && !run.cancelled && runLifecycle.isTokenActive(run.token)){
+                    if (bail && context.stateManager.getCountOfFailedTests() >= bail) {
+                        let skipped = queue.shift();
+                        while(skipped){
+                            await handleTestFileComplete(makeSkippedFileResult(skipped));
+                            skipped = queue.shift();
+                        }
+                        return;
+                    }
                     const next = queue.shift();
                     if (!next) return;
                     await runSingleFile(run, next);
@@ -4401,6 +4560,7 @@ const runBrowserController = async (context, options)=>{
                 await cancelRun(run, false);
             },
             runFiles: async (files)=>{
+                prepareWatchRerunState(context);
                 await notifyTestRunStart();
                 const rerunStartTime = Date.now();
                 const fatalErrorBeforeRun = fatalError;
@@ -4453,12 +4613,12 @@ const runBrowserController = async (context, options)=>{
                 hasFailure: false,
                 getSourcemap: getBrowserSourcemap,
                 resolveSourcemap: resolveBrowserSourcemap,
-                close: skipOnTestRunEnd ? async ()=>{
+                close: isWatchMode ? void 0 : async ()=>{
                     sessionRegistry.clear();
                     await destroyBrowserRuntime(runtime);
-                } : void 0
+                }
             };
-            if (!skipOnTestRunEnd) await notifyTestRunEnd({
+            if (isWatchMode) await notifyTestRunEnd({
                 duration
             });
             if (isWatchMode) {
@@ -4533,7 +4693,7 @@ const runBrowserController = async (context, options)=>{
         };
         context.updateReporterResultState(reporterResults, caseResults);
         const isFailure = reporterResults.some((result)=>'fail' === result.status);
-        if (isFailure) ensureProcessExitCode(1);
+        if (isWatchMode && isFailure) ensureProcessExitCode(1);
         const result = {
             results: reporterResults,
             testResults: caseResults,
@@ -4541,9 +4701,9 @@ const runBrowserController = async (context, options)=>{
             hasFailure: isFailure,
             getSourcemap: getBrowserSourcemap,
             resolveSourcemap: resolveBrowserSourcemap,
-            close: skipOnTestRunEnd ? closeHeadlessRuntime : void 0
+            close: closeHeadlessRuntime
         };
-        if (!skipOnTestRunEnd) try {
+        if (isWatchMode) try {
             await notifyTestRunEnd({
                 duration
             });
@@ -4754,7 +4914,7 @@ const runBrowserController = async (context, options)=>{
             }
         } catch (error) {
             fatalError = fatalError ?? toError(error);
-            ensureProcessExitCode(1);
+            if (isWatchMode) ensureProcessExitCode(1);
         }
         testTime = Date.now() - testStart;
     }
@@ -4781,6 +4941,7 @@ const runBrowserController = async (context, options)=>{
         }
         if (rerunPlan.normalizedAffectedTestFiles.length > 0) {
             logger.log(color.cyan(`Re-running ${rerunPlan.normalizedAffectedTestFiles.length} affected test file(s)...\n`));
+            prepareWatchRerunState(context);
             await notifyTestRunStart();
             const rerunStartTime = Date.now();
             const fatalErrorBeforeRun = fatalError;
@@ -4831,7 +4992,7 @@ const runBrowserController = async (context, options)=>{
     };
     context.updateReporterResultState(reporterResults, caseResults);
     const isFailure = reporterResults.some((result)=>'fail' === result.status);
-    if (isFailure) ensureProcessExitCode(1);
+    if (isWatchMode && isFailure) ensureProcessExitCode(1);
     const result = {
         results: reporterResults,
         testResults: caseResults,
@@ -4839,9 +5000,9 @@ const runBrowserController = async (context, options)=>{
         hasFailure: isFailure,
         getSourcemap: getBrowserSourcemap,
         resolveSourcemap: resolveBrowserSourcemap,
-        close: skipOnTestRunEnd ? closeContainerRuntime : void 0
+        close: closeContainerRuntime
     };
-    if (!skipOnTestRunEnd) try {
+    if (isWatchMode) try {
         await notifyTestRunEnd({
             duration
         });
@@ -4855,24 +5016,29 @@ const runBrowserController = async (context, options)=>{
     return result;
 };
 const listBrowserTests = async (context, options)=>{
-    const projectEntries = await resolveProjectEntries(context, options?.shardedEntries);
+    const browserProjects = options?.projects ?? getBrowserProjects(context);
+    const projectEntries = await resolveProjectEntries(context, options?.shardedEntries, browserProjects);
     const totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
-    if (0 === totalTests) return {
+    if (0 === totalTests && !hasUserRstestConfigPlugins(browserProjects)) return {
         list: [],
         close: async ()=>{}
     };
     const tempDir = join(context.rootPath, context.normalizedConfig.output.distPath.root, 'browser', `list-${Date.now()}`);
-    const browserProjects = getBrowserProjects(context);
     let runtime;
     try {
         runtime = await createBrowserRuntime({
             context,
             projectEntries,
+            browserProjects,
+            shardedEntries: options?.shardedEntries,
+            freezeShardedEntries: options?.freezeShardedEntries,
             tempDir,
             isWatchMode: false,
             containerDistPath: void 0,
             containerDevServer: void 0,
-            forceHeadless: true
+            forceHeadless: true,
+            skipProviderLaunch: options?.filesOnly,
+            appliedModifyRstestConfigEnvironments: options?.appliedModifyRstestConfigEnvironments
         });
     } catch (error) {
         const providers = [
@@ -4881,15 +5047,36 @@ const listBrowserTests = async (context, options)=>{
         logger.error(color.red(`Failed to initialize browser provider runtime (${providers.join(', ')}).`), error);
         throw error;
     }
+    if (options?.filesOnly) {
+        const list = runtime.projectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
+                    testPath,
+                    project: entry.project.name,
+                    tests: []
+                })));
+        await destroyBrowserRuntime(runtime);
+        return {
+            list,
+            close: async ()=>{}
+        };
+    }
+    if (!runtime.projectEntries.some((entry)=>entry.testFiles.length > 0)) {
+        await destroyBrowserRuntime(runtime);
+        return {
+            list: [],
+            close: async ()=>{}
+        };
+    }
     const { browser, browserLaunchOptions } = runtime;
     const projectRuntimeConfigs = browserProjects.map((project)=>({
             name: project.name,
             environmentName: project.environmentName,
             projectRoot: normalize(project.rootPath),
-            runtimeConfig: serializableConfig(getRuntimeConfigFromProject(project)),
+            runtimeConfig: serializableConfig(projectRuntimeConfig(project, {
+                envMode: 'static'
+            })),
             viewport: project.normalizedConfig.browser.viewport
         }));
-    const maxTestTimeoutForRpc = Math.max(...browserProjects.map((p)=>p.normalizedConfig.testTimeout ?? DEFAULT_TEST_TIMEOUT));
+    const maxTestTimeoutForRpc = getMaxTestTimeoutForRpc(browserProjects);
     const hostOptions = {
         rootPath: normalize(context.rootPath),
         projects: projectRuntimeConfigs,
@@ -4906,6 +5093,7 @@ const listBrowserTests = async (context, options)=>{
         viewport: null
     });
     const serializedOptions = serializeForInlineScript(hostOptions);
+    const collectTimeoutMs = 30000;
     const collectFromServer = async (server)=>{
         const results = [];
         let error = null;
@@ -4950,13 +5138,12 @@ const listBrowserTests = async (context, options)=>{
         await page.goto(`http://localhost:${server.port}/runner.html`, {
             waitUntil: 'load'
         });
-        const timeoutMs = 30000;
         let timeoutId;
         const timeoutPromise = new Promise((resolve)=>{
             timeoutId = setTimeout(()=>{
-                if (!collectCompleted) logger.warn(color.yellow(`[List] Browser test collection timed out after ${timeoutMs}ms`));
+                if (!collectCompleted) logger.warn(color.yellow(`[List] Browser test collection timed out after ${collectTimeoutMs}ms`));
                 resolve();
-            }, timeoutMs);
+            }, collectTimeoutMs);
         });
         await Promise.race([
             collectPromise,
@@ -5006,10 +5193,92 @@ const listBrowserTests = async (context, options)=>{
         close: cleanup
     };
 };
+const emptyOutcome = ()=>({
+        results: [],
+        testResults: [],
+        errors: [],
+        testPaths: [],
+        duration: {
+            buildTime: 0,
+            testTime: 0
+        }
+    });
+async function createBrowserExecutor(context, options) {
+    const { projects, coverageProvider, freezeShardedEntries, filesOnly, allowEmptyRun, appliedModifyRstestConfigEnvironments } = options;
+    let deferredClose;
+    let inFlightCycle;
+    const foldOutcome = (result)=>{
+        if (!result) return emptyOutcome();
+        const map = buildBrowserCoverageMap(result.results, coverageProvider);
+        return {
+            results: result.results,
+            testResults: result.testResults,
+            errors: result.unhandledErrors ?? [],
+            testPaths: result.results.map((r)=>r.testPath),
+            duration: {
+                buildTime: result.duration.buildTime,
+                testTime: result.duration.testTime
+            },
+            coverage: {
+                map: map?.toJSON()
+            },
+            resolveSourcemap: result.resolveSourcemap
+        };
+    };
+    return {
+        name: 'browser',
+        projects,
+        async init () {},
+        async runCycle (opts) {
+            const cycle = runBrowserController(context, {
+                projects,
+                shardedEntries: opts.shardedEntries,
+                freezeShardedEntries,
+                allowEmptyRun,
+                appliedModifyRstestConfigEnvironments,
+                onTraceEvents: opts.onTraceEvents,
+                env: opts.env
+            });
+            inFlightCycle = cycle;
+            try {
+                const result = await cycle;
+                deferredClose = result?.close;
+                return foldOutcome(result);
+            } finally{
+                inFlightCycle = void 0;
+            }
+        },
+        async collect (opts) {
+            const pending = listBrowserTests(context, {
+                projects,
+                shardedEntries: opts.shardedEntries,
+                freezeShardedEntries,
+                filesOnly,
+                appliedModifyRstestConfigEnvironments
+            });
+            inFlightCycle = pending;
+            try {
+                const { list, close } = await pending;
+                deferredClose = close;
+                return {
+                    list
+                };
+            } finally{
+                inFlightCycle = void 0;
+            }
+        },
+        async close () {
+            if (inFlightCycle) await inFlightCycle.catch(()=>void 0);
+            const close = deferredClose;
+            deferredClose = void 0;
+            await close?.();
+        }
+    };
+}
 async function runBrowserTests(context, options) {
     return runBrowserController(context, options);
 }
 async function src_listBrowserTests(context, options) {
     return listBrowserTests(context, options);
 }
-export { runBrowserTests, src_listBrowserTests as listBrowserTests, validateBrowserConfig };
+export { createBrowserExecutor, runBrowserTests, src_listBrowserTests as listBrowserTests, validateBrowserConfig };