@rstest/browser 0.11.0 → 0.11.2

package/src/hostController.ts

@@ -9,23 +9,32 @@ import {
   type BrowserTestRunOptions,
   type BrowserTestRunResult,
   type CoverageMapData,
+  type ListBrowserTestsOptions,
   color,
   createCoverageProvider,
+  createRunnerEventSink,
+  createSilentConsoleController,
   DEFAULT_TEST_TIMEOUT,
   type FormattedError,
   getNoTestFilesMessage,
   getSetupFiles,
   getTestEntries,
+  hasUserRstestConfigPlugins,
+  initModifyRstestConfigHooks,
   isDebug,
   type ListCommandResult,
   loadCoverageProvider,
   logger,
+  prepareWatchRerunState,
+  projectRuntimeConfig,
   PhaseTracker,
   type ProjectContext,
   type Reporter,
+  type RunnerEventSink,
   type RstestContext,
-  type RuntimeConfig,
   resolveProjectBuildCache,
+  resolveSnapshotPathDefault,
+  resolveShardedEntries,
   RSTEST_ENV_SYMBOL_KEY,
   rsbuild,
   serializableConfig,
@@ -36,7 +45,7 @@ import {
 } from '@rstest/core/internal/browser';
 import { type BirpcReturn, createBirpc } from 'birpc';
 import openEditor from 'open-editor';
-import { basename, dirname, join, normalize, relative, resolve } from 'pathe';
+import { dirname, join, normalize, relative, resolve } from 'pathe';
 import picomatch from 'picomatch';
 import sirv from 'sirv';
 import { type WebSocket, WebSocketServer } from 'ws';
@@ -45,6 +54,7 @@ import {
   createHostDispatchRouter,
   type HostDispatchRouterOptions,
 } from './dispatchCapabilities';
+import { validateBrowserConfig } from './configValidation';
 import { createHeadedSerialTaskQueue } from './headedSerialTaskQueue';
 import { createHeadlessLatestRerunScheduler } from './headlessLatestRerunScheduler';
 import { attachHeadlessRunnerTransport } from './headlessTransport';
@@ -97,6 +107,8 @@ import { collectWatchTestFiles, planWatchRerun } from './watchRerunPlanner';
 const { createRsbuild, rspack } = rsbuild;
 type RsbuildDevServer = rsbuild.RsbuildDevServer;
 type RsbuildInstance = rsbuild.RsbuildInstance;
+type RsbuildEnvironmentConfig = rsbuild.EnvironmentConfig &
+  Pick<rsbuild.RsbuildConfig, 'root'>;
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const OPTIONS_PLACEHOLDER = '__RSTEST_OPTIONS_PLACEHOLDER__';
@@ -200,10 +212,6 @@ const getFileTaskId = (testPath: string): string => {
   return `file:${testPath}`;
 };
 
-const getBufferedLogTaskId = (log: UserConsoleLog): string => {
-  return log.taskId ?? getFileTaskId(log.testPath);
-};
-
 const createDeferredPromise = <T>(): DeferredPromise<T> => {
   let resolve!: DeferredPromise<T>['resolve'];
   let reject!: DeferredPromise<T>['reject'];
@@ -433,6 +441,7 @@ type BrowserRuntime = {
   dispatchHandlers: Map<string, BrowserDispatchHandler>;
   wss: WebSocketServer;
   rpcManager?: ContainerRpcManager;
+  projectEntries: BrowserProjectEntries[];
 };
 
 // ============================================================================
@@ -973,82 +982,25 @@ const getAffectedTestFiles = (
   return Array.from(affectedFiles);
 };
 
-const getRuntimeConfigFromProject = (
-  project: ProjectContext,
-): RuntimeConfig => {
-  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;
+const getBrowserProjects = (context: RstestContext): ProjectContext[] =>
+  context.projects.filter(
+    (project) => project.normalizedConfig.browser.enabled,
+  );
 
-  return {
-    // Propagate NODE_ENV and the RSTEST flag from the host so
-    // `process.env.NODE_ENV` / `process.env.RSTEST` (rewritten to the
-    // `RSTEST_ENV_SYMBOL_KEY` symbol store) resolve in browser tests the same
-    // way they do in Node mode, where `prepare.ts` sets them on the real
-    // `process.env`.
-    // User-supplied `env` wins so explicit overrides still take effect.
-    // See https://github.com/web-infra-dev/rstest/issues/1351
-    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 getBrowserRsbuildEnvironmentConfig = (
+  project: ProjectContext,
+): RsbuildEnvironmentConfig => ({
+  plugins: project.normalizedConfig.plugins,
+  root: project.rootPath,
+});
 
-const getBrowserProjects = (context: RstestContext): ProjectContext[] => {
-  return context.projects.filter(
-    (project) => project.normalizedConfig.browser.enabled,
+// Max testTimeout across browser projects, used as the host->client RPC timeout.
+const getMaxTestTimeoutForRpc = (projects: ProjectContext[]): number =>
+  Math.max(
+    ...projects.map(
+      (p) => p.normalizedConfig.testTimeout ?? DEFAULT_TEST_TIMEOUT,
+    ),
   );
-};
 
 const getBrowserLaunchOptions = (
   project: ProjectContext,
@@ -1118,10 +1070,11 @@ const resolveProviderForTestPath = ({
 
 const collectProjectEntries = async (
   context: RstestContext,
+  // The explicit browser-project subset the executor was constructed with. Falls
+  // back to re-deriving from `context` for internal callers (e.g. the watch
+  // plugin) that do not carry the plan's project list.
+  browserProjects: ProjectContext[] = getBrowserProjects(context),
 ): Promise<BrowserProjectEntries[]> => {
-  // Only collect entries for browser mode projects
-  const browserProjects = getBrowserProjects(context);
-
   return Promise.all(
     browserProjects.map(async (project) => {
       const {
@@ -1455,16 +1408,28 @@ const registerWatchCleanup = (): void => {
 
 const createBrowserRuntime = async ({
   context,
-  projectEntries,
+  projectEntries: initialProjectEntries,
+  browserProjects,
+  shardedEntries,
+  freezeShardedEntries,
   tempDir,
   isWatchMode,
   onTriggerRerun,
   containerDistPath,
   containerDevServer,
   forceHeadless,
+  skipProviderLaunch,
+  appliedModifyRstestConfigEnvironments,
 }: {
   context: RstestContext;
   projectEntries: BrowserProjectEntries[];
+  /**
+   * The explicit browser-project subset (plan output). Drives launch-option
+   * consistency and the container origin (`browserProjects[0]`).
+   */
+  browserProjects: ProjectContext[];
+  shardedEntries?: Map<string, { entries: Record<string, string> }>;
+  freezeShardedEntries?: boolean;
   tempDir: string;
   isWatchMode: boolean;
   onTriggerRerun?: () => Promise<void>;
@@ -1472,6 +1437,8 @@ const createBrowserRuntime = async ({
   containerDevServer?: string;
   /** Force headless mode regardless of user config (used for list command) */
   forceHeadless?: boolean;
+  skipProviderLaunch?: boolean;
+  appliedModifyRstestConfigEnvironments?: Set<string>;
 }): Promise<BrowserRuntime> => {
   // ---- Shared singletons (created once, wired into every project server) ----
   const containerHtmlTemplate = containerDistPath
@@ -1493,9 +1460,83 @@ const createBrowserRuntime = async ({
     }
   };
 
-  const browserProjects = getBrowserProjects(context);
-  const browserLaunchOptions =
+  let browserLaunchOptions =
     ensureConsistentBrowserLaunchOptions(browserProjects);
+  let projectEntries = initialProjectEntries;
+  const manifestModules: Array<{
+    manifestPath: string;
+    project: ProjectContext;
+    modules: Record<string, string>;
+  }> = [];
+
+  const createRuntimeWithoutProvider = (): BrowserRuntime => {
+    const firstProject = browserProjects[0]!;
+    return {
+      projectServers: new Map(),
+      containerServer: {
+        projectName: firstProject.name,
+        environmentName: firstProject.environmentName,
+        rsbuildInstance: undefined as unknown as RsbuildInstance,
+        devServer: {
+          close: async () => undefined,
+        } as RsbuildDevServer,
+        port: 0,
+        manifestPath: '',
+      },
+      browser: undefined as unknown as BrowserProviderBrowser,
+      browserLaunchOptions,
+      wsPort: 0,
+      tempDir,
+      setContainerOptions,
+      dispatchHandlers,
+      wss: undefined as unknown as WebSocketServer,
+      projectEntries,
+    };
+  };
+
+  const getProjectEntry = (project: ProjectContext) =>
+    projectEntries.find(
+      (item) => item.project.environmentName === project.environmentName,
+    );
+
+  const refreshManifestModule = (manifestModule: {
+    manifestPath: string;
+    project: ProjectContext;
+    modules: Record<string, string>;
+  }): void => {
+    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 (): Promise<void> => {
+    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);
+    }
+  };
 
   // Rstest internal aliases that must not be overridden by user config
   const browserRuntimePath = fileURLToPath(
@@ -1591,10 +1632,6 @@ const createBrowserRuntime = async ({
     }
   };
 
-  const entryByEnvironmentName = new Map(
-    projectEntries.map((entry) => [entry.project.environmentName, entry]),
-  );
-
   // ---- Build one isolated rsbuild instance + dev server per project ----
   const buildProjectServer = async (
     project: ProjectContext,
@@ -1605,20 +1642,27 @@ const createBrowserRuntime = async ({
       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 = {
@@ -1631,11 +1675,10 @@ const createBrowserRuntime = async ({
     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,
           // Each project gets its own dev server. Honor an explicitly
@@ -1649,11 +1692,24 @@ const createBrowserRuntime = async ({
         },
         dev: createBrowserRsbuildDevConfig(enableHmr),
         environments: {
-          [project.environmentName]: {},
+          [project.environmentName]:
+            getBrowserRsbuildEnvironmentConfig(project),
         },
       },
     });
 
+    initModifyRstestConfigHooks(
+      context,
+      rsbuildInstance,
+      [project],
+      [project],
+      {
+        getEnvironmentConfig: getBrowserRsbuildEnvironmentConfig,
+        onModifyRstestConfigApplied: refreshProjectEntries,
+        appliedEnvironmentNames: appliedModifyRstestConfigEnvironments,
+      },
+    );
+
     // Add plugin to merge user Rsbuild config with rstest required config
     rsbuildInstance.addPlugins([
       {
@@ -1736,7 +1792,7 @@ const createBrowserRuntime = async ({
 
                       // Extract and merge sourcemaps from pre-built @rstest/core files
                       // This preserves the sourcemap chain for inline snapshot support
-                      // See: https://rspack.dev/config/module-rules#rulesextractsourcemap
+                      // See: https://rspack.rs/config/module-rules#rulesextractsourcemap
                       const browserRuntimeDir = dirname(browserRuntimePath);
                       rspackConfig.module = rspackConfig.module || {};
                       rspackConfig.module.rules =
@@ -1822,6 +1878,20 @@ const createBrowserRuntime = async ({
       ]);
     }
 
+    if (skipProviderLaunch) {
+      await rsbuildInstance.initConfigs({ action: 'dev' });
+      return {
+        projectName: project.name,
+        environmentName: project.environmentName,
+        rsbuildInstance,
+        devServer: {
+          close: async () => undefined,
+        } as RsbuildDevServer,
+        port: 0,
+        manifestPath,
+      };
+    }
+
     // Register coverage plugin if this project enables coverage
     const coverage = project.normalizedConfig.coverage;
     if (coverage?.enabled && context.command !== 'list') {
@@ -1948,6 +2018,10 @@ const createBrowserRuntime = async ({
     throw error;
   }
 
+  if (skipProviderLaunch) {
+    return createRuntimeWithoutProvider();
+  }
+
   // browserProjects is non-empty (ensureConsistentBrowserLaunchOptions throws
   // otherwise) and index 0 is the designated container origin.
   const containerServer = projectServers.get(browserProjects[0]!.name)!;
@@ -1983,6 +2057,7 @@ const createBrowserRuntime = async ({
       setContainerOptions,
       dispatchHandlers,
       wss,
+      projectEntries,
     };
   } catch (error) {
     wss.close();
@@ -1993,10 +2068,10 @@ const createBrowserRuntime = async ({
 
 async function resolveProjectEntries(
   context: RstestContext,
-  shardedEntries?: Map<string, { entries: Record<string, string> }>,
+  shardedEntries: Map<string, { entries: Record<string, string> }> | undefined,
+  browserProjects: ProjectContext[],
 ): Promise<BrowserProjectEntries[]> {
   if (shardedEntries) {
-    const browserProjects = getBrowserProjects(context);
     const projectEntries: BrowserProjectEntries[] = [];
     for (const project of browserProjects) {
       const entryInfo = shardedEntries.get(project.environmentName);
@@ -2014,7 +2089,7 @@ async function resolveProjectEntries(
     }
     return projectEntries;
   }
-  return collectProjectEntries(context);
+  return collectProjectEntries(context, browserProjects);
 }
 
 // ============================================================================
@@ -2026,11 +2101,18 @@ export const runBrowserController = async (
   options?: BrowserTestRunOptions,
 ): Promise<BrowserTestRunResult | void> => {
   const {
-    skipOnTestRunEnd = false,
     allowEmptyWatchRun = false,
+    allowEmptyRun = false,
+    filesOnly = false,
     onTraceEvents,
+    env,
   } = options ?? {};
   const buildStart = Date.now();
+  // Non-watch vs watch is the live switch for self-finalize: in non-watch runs
+  // core owns the unified finalize (reporters, exit code, coverage) through
+  // `finalizeRunCycle`, so the host never self-finalizes and always returns a
+  // fully-populated result with `close`. Watch reruns keep their host-driven
+  // per-rerun finalize.
   const isWatchMode = context.command === 'watch';
 
   // Per-file PhaseTrackers, populated only when `--trace` is on (caller
@@ -2041,7 +2123,11 @@ export const runBrowserController = async (
   const phaseTrackers = onTraceEvents
     ? new Map<string, PhaseTracker>()
     : undefined;
-  const browserProjects = getBrowserProjects(context);
+  // Explicit projects input (plan output) replaces re-deriving `browser.enabled`
+  // projects from `context`, whose `projects` array is mutated during planning.
+  // Falls back to re-derivation only when the caller passes no list at all —
+  // an explicit empty subset must stay empty, not widen to every project.
+  const browserProjects = options?.projects ?? getBrowserProjects(context);
   const useHeadlessDirect = browserProjects.every(
     (project) => project.normalizedConfig.browser.headless,
   );
@@ -2109,7 +2195,7 @@ export const runBrowserController = async (
       close,
     };
 
-    if (!skipOnTestRunEnd) {
+    if (isWatchMode) {
       for (const reporter of context.reporters) {
         await (reporter as Reporter).onTestRunEnd?.({
           results: [],
@@ -2133,11 +2219,16 @@ export const runBrowserController = async (
     error: unknown,
     cleanup?: () => Promise<void>,
   ): Promise<BrowserTestRunResult> => {
-    ensureProcessExitCode(1);
+    // Non-watch runs defer the exit code to core's `finalizeRunCycle`, which
+    // raises it from the returned outcome's `errors`. Watch reruns keep owning
+    // their own exit code.
+    if (isWatchMode) {
+      ensureProcessExitCode(1);
+    }
 
     const normalizedError = toError(error);
 
-    if (cleanup && skipOnTestRunEnd) {
+    if (cleanup && !isWatchMode) {
       return buildErrorResult(normalizedError, cleanup);
     }
 
@@ -2159,7 +2250,7 @@ export const runBrowserController = async (
   };
 
   const notifyTestRunStart = async (): Promise<void> => {
-    if (skipOnTestRunEnd) {
+    if (!isWatchMode) {
       return;
     }
 
@@ -2188,7 +2279,7 @@ export const runBrowserController = async (
     unhandledErrors?: Error[];
     filterRerunTestPaths?: string[];
   }): Promise<void> => {
-    if (skipOnTestRunEnd) {
+    if (!isWatchMode) {
       return;
     }
 
@@ -2249,19 +2340,38 @@ export const runBrowserController = async (
     }
   }
 
-  const projectEntries = await resolveProjectEntries(
+  let projectEntries = await resolveProjectEntries(
     context,
     options?.shardedEntries,
+    browserProjects,
   );
-  const totalTests = projectEntries.reduce(
+  let totalTests = projectEntries.reduce(
     (total, item) => total + item.testFiles.length,
     0,
   );
   const shouldKeepWatchingWithEmptySet = isWatchMode && allowEmptyWatchRun;
+  const shouldInitializeEmptyBrowserHooks =
+    totalTests === 0 && hasUserRstestConfigPlugins(browserProjects);
 
-  if (totalTests === 0) {
+  const createEmptyRunResult = (): BrowserTestRunResult => {
+    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 = (): boolean => {
     const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
-    if (!skipOnTestRunEnd) {
+    if (isWatchMode || !allowEmptyRun) {
       const message = shouldKeepWatchingWithEmptySet
         ? 'No test files found.'
         : getNoTestFilesMessage({
@@ -2288,15 +2398,30 @@ export const runBrowserController = async (
       }
     }
 
-    if (code !== 0 && !shouldKeepWatchingWithEmptySet) {
+    // In non-watch runs the host returns a void outcome and core's
+    // `reportNoTestFiles` owns the exit code and the no-test reporter lifecycle;
+    // the host must not set the code itself. Watch keeps its own exit code.
+    if (
+      isWatchMode &&
+      code !== 0 &&
+      !shouldKeepWatchingWithEmptySet &&
+      !allowEmptyRun
+    ) {
       ensureProcessExitCode(code);
     }
-    if (!shouldKeepWatchingWithEmptySet) {
-      return;
+
+    return !shouldKeepWatchingWithEmptySet;
+  };
+
+  if (totalTests === 0 && !shouldInitializeEmptyBrowserHooks) {
+    if (reportEmptyTestSet()) {
+      return allowEmptyRun ? createEmptyRunResult() : undefined;
     }
   }
 
-  await notifyTestRunStart();
+  if (!filesOnly) {
+    await notifyTestRunStart();
+  }
 
   const enableCliShortcuts = isWatchMode && isBrowserWatchCliShortcutsEnabled();
   const browserTempOutputRoot = context.normalizedConfig.output.distPath.root;
@@ -2327,6 +2452,9 @@ export const runBrowserController = async (
       runtime = await createBrowserRuntime({
         context,
         projectEntries,
+        browserProjects,
+        shardedEntries: options?.shardedEntries,
+        freezeShardedEntries: options?.freezeShardedEntries,
         tempDir,
         isWatchMode,
         onTriggerRerun: isWatchMode
@@ -2336,6 +2464,9 @@ export const runBrowserController = async (
           : undefined,
         containerDistPath,
         containerDevServer,
+        skipProviderLaunch: filesOnly,
+        appliedModifyRstestConfigEnvironments:
+          options?.appliedModifyRstestConfigEnvironments,
       });
     } catch (error) {
       return failWithError(error, async () => {
@@ -2355,9 +2486,37 @@ export const runBrowserController = async (
     }
   }
 
-  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 (totalTests === 0 && reportEmptyTestSet()) {
+    await destroyBrowserRuntime(runtime);
+    return allowEmptyRun ? createEmptyRunResult() : undefined;
+  }
+
+  const { browser, browserLaunchOptions, wsPort, wss } = runtime;
+
   // Collect all test files from project entries with project info
   // Normalize paths to posix format for cross-platform compatibility
   const allTestFiles: TestFileInfo[] = projectEntries.flatMap((entry) =>
@@ -2374,17 +2533,17 @@ export const runBrowserController = async (
       name: project.name,
       environmentName: project.environmentName,
       projectRoot: normalize(project.rootPath),
-      runtimeConfig: serializableConfig(getRuntimeConfigFromProject(project)),
+      runtimeConfig: serializableConfig(
+        // `env` is the post-globalSetup change-set from the core pre-cycle
+        // stage; the projection layers it between the static base and the
+        // user `test.env` config.
+        projectRuntimeConfig(project, { envMode: 'static', envOverlay: env }),
+      ),
       viewport: project.normalizedConfig.browser.viewport,
     }),
   );
 
-  // Get max testTimeout from all browser projects for RPC timeout
-  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]) => [
@@ -2497,18 +2656,64 @@ export const runBrowserController = async (
   const caseResults: TestResult[] = [];
   let fatalError: Error | null = null;
 
+  // Runner lifecycle events flow through the shared RunnerEventSink (the same
+  // pump the node pool uses), so browser mode feeds stateManager and fans out to
+  // reporters via one implementation. One sink is bound per browser project up
+  // front from the executor's own project plan (`browserProjects`) — never from
+  // `context.projects`, which planning mutates to also contain node projects. The
+  // previous lazy resolver fell back to `context.projects[0]`, so a browser event
+  // could be attributed to a *node* project's config; binding per browser project
+  // here removes that fallback and keeps per-project `onConsoleLog` filtering and
+  // `resolveSnapshotPath` correct across browser projects that share a relative
+  // test path.
+  const runnerSinks = new Map<string, RunnerEventSink>(
+    browserProjects.map((project) => [
+      project.name,
+      createRunnerEventSink(context, project.normalizedConfig),
+    ]),
+  );
+  const firstBrowserSink = runnerSinks.get(browserProjects[0]!.name)!;
+
+  // testPath -> owning project name, stamped from the authoritative client
+  // file-start event (it carries the manifest-resolved projectName) before any
+  // other per-file event for that path fires — including on watch reruns, so the
+  // mapping stays correct when a rerun adds a file. Fully eliminating this map in
+  // favor of a project stamp on every wire event is deferred (it would add
+  // `project` to the shared `TestResult`/`TestFileResult` payloads).
+  const projectNameByTestPath = new Map<string, string>();
+
+  const sinkForProjectName = (projectName: string): RunnerEventSink =>
+    runnerSinks.get(projectName) ?? firstBrowserSink;
+
+  const sinkForTestPath = (testPath: string): RunnerEventSink => {
+    const projectName = projectNameByTestPath.get(testPath);
+    return projectName ? sinkForProjectName(projectName) : firstBrowserSink;
+  };
+
+  // Silent-console buffering runs through the shared controller — the same
+  // engine the node worker uses — so `silent: 'passed-only'` buffers logs and
+  // replays only the failing tasks'. Intercepted replays route through the
+  // owning project's sink, so they honor per-project `onConsoleLog` and
+  // `disableConsoleIntercept` (the browser host previously flushed straight to
+  // reporters, bypassing both). `writeOriginalLog` is a host-side no-op: page
+  // logs have no host "original stream" — the page console and headed terminal
+  // forwarding already show them, so re-emitting here would double-print.
+  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: string): Promise<string> {
-      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: string): Promise<string | null> {
       try {
@@ -2534,6 +2739,7 @@ export const runBrowserController = async (
   const handleTestFileStart = async (
     payload: TestFileStartPayload,
   ): Promise<void> => {
+    projectNameByTestPath.set(payload.testPath, payload.projectName);
     if (phaseTrackers) {
       const tracker = new PhaseTracker({
         trace: {
@@ -2545,51 +2751,37 @@ export const runBrowserController = async (
       tracker.transition('prepare');
       phaseTrackers.set(payload.testPath, tracker);
     }
-    await Promise.all(
-      context.reporters.map((reporter) =>
-        (reporter as Reporter).onTestFileStart?.({
-          testId: getFileTaskId(payload.testPath),
-          testPath: payload.testPath,
-          tests: [],
-        }),
-      ),
-    );
+    // The client sends `{ testPath, projectName }`; the sink adapter builds the
+    // `TestFileInfo` the reporters and stateManager expect.
+    await sinkForProjectName(payload.projectName).onTestFileStart({
+      testId: getFileTaskId(payload.testPath),
+      testPath: payload.testPath,
+      tests: [],
+    });
   };
 
   const handleTestFileReady = async (
     payload: TestFileReadyPayload,
   ): Promise<void> => {
     phaseTrackers?.get(payload.testPath)?.transition('tests');
-    await Promise.all(
-      context.reporters.map((reporter) =>
-        (reporter as Reporter).onTestFileReady?.(payload),
-      ),
-    );
+    await sinkForTestPath(payload.testPath).onTestFileReady(payload);
   };
 
   const handleTestSuiteStart = async (
     payload: TestSuiteStartPayload,
   ): Promise<void> => {
     phaseTrackers?.get(payload.testPath)?.recordSuiteStart(payload);
-    await Promise.all(
-      context.reporters.map((reporter) =>
-        (reporter as Reporter).onTestSuiteStart?.(payload),
-      ),
-    );
+    await sinkForTestPath(payload.testPath).onTestSuiteStart(payload);
   };
 
   const handleTestSuiteResult = async (
     payload: TestSuiteResultPayload,
   ): Promise<void> => {
     phaseTrackers?.get(payload.testPath)?.recordSuiteResult(payload);
-    await Promise.all(
-      context.reporters.map((reporter) =>
-        (reporter as Reporter).onTestSuiteResult?.(payload),
-      ),
-    );
+    await sinkForTestPath(payload.testPath).onTestSuiteResult(payload);
 
     if (context.normalizedConfig.silent === 'passed-only') {
-      await flushBufferedLogsForTask({
+      silentConsoleController.flushBufferedLogsForTask({
         taskId: payload.testId,
         status: payload.status,
         taskParentNames: payload.parentNames,
@@ -2603,24 +2795,17 @@ export const runBrowserController = async (
     payload: TestCaseStartPayload,
   ): Promise<void> => {
     phaseTrackers?.get(payload.testPath)?.recordCaseStart(payload);
-    await Promise.all(
-      context.reporters.map((reporter) =>
-        (reporter as Reporter).onTestCaseStart?.(payload),
-      ),
-    );
+    // Fire-and-forget on both transports (the sink does not await case-start).
+    sinkForTestPath(payload.testPath).onTestCaseStart(payload);
   };
 
   const handleTestCaseResult = async (payload: TestResult): Promise<void> => {
     caseResults.push(payload);
     phaseTrackers?.get(payload.testPath)?.recordCaseResult(payload);
-    await Promise.all(
-      context.reporters.map((reporter) =>
-        (reporter as Reporter).onTestCaseResult?.(payload),
-      ),
-    );
+    await sinkForTestPath(payload.testPath).onTestCaseResult(payload);
 
     if (context.normalizedConfig.silent === 'passed-only') {
-      await flushBufferedLogsForTask({
+      silentConsoleController.flushBufferedLogsForTask({
         taskId: payload.testId,
         status: payload.status,
         taskParentNames: payload.parentNames,
@@ -2635,9 +2820,6 @@ export const runBrowserController = async (
   ): Promise<void> => {
     reporterResults.push(payload);
     context.updateReporterResultState([payload], payload.results);
-    if (payload.snapshotResult) {
-      context.snapshotManager.add(payload.snapshotResult);
-    }
 
     if (phaseTrackers) {
       const tracker = phaseTrackers.get(payload.testPath);
@@ -2650,7 +2832,7 @@ export const runBrowserController = async (
     }
 
     if (context.normalizedConfig.silent === 'passed-only') {
-      await flushBufferedLogsForTask({
+      silentConsoleController.flushBufferedLogsForTask({
         taskId: payload.testId,
         status: payload.status,
         taskParentNames: payload.parentNames,
@@ -2659,12 +2841,12 @@ export const runBrowserController = async (
       });
     }
 
-    await Promise.all(
-      context.reporters.map((reporter) =>
-        (reporter as Reporter).onTestFileResult?.(payload),
-      ),
-    );
-    if (payload.status === 'fail') {
+    // Feeds stateManager, fans out onTestFileResult to reporters, and ingests
+    // payload.snapshotResult (the snapshotManager.add moved into the sink).
+    await sinkForTestPath(payload.testPath).onTestFileResult(payload);
+    // In non-watch runs core owns the exit code via `finalizeRunCycle` (the
+    // failing file rides the returned outcome); watch reruns set it here.
+    if (isWatchMode && payload.status === 'fail') {
       ensureProcessExitCode(1);
     }
   };
@@ -2681,135 +2863,17 @@ export const runBrowserController = async (
       type: payload.type,
       trace: payload.trace,
     };
-    if (context.normalizedConfig.silent === true) {
-      return;
-    }
-
-    if (context.normalizedConfig.silent === 'passed-only') {
-      bufferConsoleLog(log);
-      return;
-    }
-
-    if (context.normalizedConfig.disableConsoleIntercept) {
-      return;
-    }
-
-    await emitUserConsoleLog(log);
+    silentConsoleController.onConsoleLog(log);
   };
 
   const handleFatal = async (payload: FatalPayload): Promise<void> => {
     const error = new Error(payload.message);
     error.stack = payload.stack;
     fatalError = error;
-    ensureProcessExitCode(1);
-  };
-
-  const bufferedConsoleLogs = new Map<string, UserConsoleLog[]>();
-  const suiteIdsByChain = new Map<string, string>();
-
-  const getSuiteChainKey = (names: string[]): string => {
-    return names.join('\u0000');
-  };
-
-  const pushTaskId = (taskIds: string[], taskId: string): void => {
-    if (!taskIds.includes(taskId)) {
-      taskIds.push(taskId);
-    }
-  };
-
-  const shouldEmitUserConsoleLog = (log: UserConsoleLog): boolean => {
-    return (
-      context.normalizedConfig.onConsoleLog?.(log.content, log.type) !== false
-    );
-  };
-
-  const emitUserConsoleLog = async (log: UserConsoleLog): Promise<void> => {
-    if (!shouldEmitUserConsoleLog(log)) {
-      return;
-    }
-
-    await Promise.all(
-      context.reporters.map((reporter) =>
-        (reporter as Reporter).onUserConsoleLog?.(log),
-      ),
-    );
-  };
-
-  const bufferConsoleLog = (log: UserConsoleLog): void => {
-    const taskId = getBufferedLogTaskId(log);
-    const logs = bufferedConsoleLogs.get(taskId) || [];
-    logs.push(log);
-    bufferedConsoleLogs.set(taskId, logs);
-
-    if (log.taskType === 'suite' && log.taskId) {
-      suiteIdsByChain.set(
-        getSuiteChainKey([...(log.taskParentNames || []), log.taskName || '']),
-        log.taskId,
-      );
-    }
-  };
-
-  const flushBufferedLogsForTask = async ({
-    taskId,
-    status,
-    taskParentNames,
-    taskType,
-    testPath,
-  }: {
-    taskId: string;
-    status: TestResult['status'];
-    taskParentNames?: string[];
-    taskType?: 'file' | 'suite' | 'case';
-    testPath: string;
-  }): Promise<void> => {
-    if (status !== 'fail') {
-      bufferedConsoleLogs.delete(taskId);
-      return;
-    }
-
-    const taskIdsToFlush: string[] = [];
-
-    if (taskType === 'case') {
-      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 (taskType === 'suite') {
-      pushTaskId(taskIdsToFlush, getFileTaskId(testPath));
-      pushTaskId(taskIdsToFlush, taskId);
-    }
-
-    if (taskType === 'file') {
-      pushTaskId(taskIdsToFlush, taskId);
-    }
-
-    for (const bufferedTaskId of taskIdsToFlush) {
-      const logs = bufferedConsoleLogs.get(bufferedTaskId);
-      if (!logs) {
-        continue;
-      }
-
-      bufferedConsoleLogs.delete(bufferedTaskId);
-
-      for (const log of logs) {
-        await Promise.all(
-          context.reporters.map((reporter) =>
-            (reporter as Reporter).onUserConsoleLog?.(log),
-          ),
-        );
-      }
+    // Non-watch runs surface the fatal error through the returned outcome and
+    // let core's `finalizeRunCycle` set the exit code; watch reruns set it here.
+    if (isWatchMode) {
+      ensureProcessExitCode(1);
     }
   };
 
@@ -3117,6 +3181,18 @@ export const runBrowserController = async (
       }
     };
 
+    // Bailed files never run, so they carry no case results — mirror the node
+    // pool's skip result (`runInPool.ts`) so the summary reports them as skipped
+    // rather than dropping them silently.
+    const makeSkippedFileResult = (file: TestFileInfo): TestFileResult => ({
+      testId: getFileTaskId(file.testPath),
+      status: 'skip',
+      name: '',
+      testPath: file.testPath,
+      project: file.projectName,
+      results: [],
+    });
+
     const runFilesWithPool = async (files: TestFileInfo[]): Promise<void> => {
       if (files.length === 0) {
         return;
@@ -3134,6 +3210,7 @@ export const runBrowserController = async (
 
       const queue = [...files];
       const concurrency = getHeadlessConcurrency(context, queue.length);
+      const bail = context.normalizedConfig.bail;
 
       const worker = async (): Promise<void> => {
         while (
@@ -3141,6 +3218,19 @@ export const runBrowserController = async (
           !run.cancelled &&
           runLifecycle.isTokenActive(run.token)
         ) {
+          // Cross-file bail gate (parity with the node pool's pickup-time skip
+          // at `runInPool.ts`): once the cycle-wide failed count reaches `bail`,
+          // drain the remaining files as skipped instead of running them. The
+          // count is cycle-scoped because `stateManager` is reset at the top of
+          // every run/rerun (initial run and `prepareWatchRerunState`).
+          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;
@@ -3173,6 +3263,12 @@ export const runBrowserController = async (
         await cancelRun(run, false);
       },
       runFiles: async (files) => {
+        // Clear the previous cycle's stateManager/snapshotManager before the
+        // rerun streams new events through the shared sink — otherwise failed
+        // counts (bail) and snapshot summaries accumulate across reruns. The
+        // initial run does not reach here (it calls `runFilesWithPool`
+        // directly), so only reruns reset.
+        prepareWatchRerunState(context);
         await notifyTestRunStart();
 
         const rerunStartTime = Date.now();
@@ -3233,7 +3329,7 @@ export const runBrowserController = async (
         hasFailure: false,
         getSourcemap: getBrowserSourcemap,
         resolveSourcemap: resolveBrowserSourcemap,
-        close: skipOnTestRunEnd
+        close: !isWatchMode
           ? async () => {
               sessionRegistry.clear();
               await destroyBrowserRuntime(runtime);
@@ -3241,7 +3337,7 @@ export const runBrowserController = async (
           : undefined,
       };
 
-      if (!skipOnTestRunEnd) {
+      if (isWatchMode) {
         await notifyTestRunEnd({ duration });
       }
 
@@ -3365,7 +3461,9 @@ export const runBrowserController = async (
     const isFailure = reporterResults.some(
       (result: TestFileResult) => result.status === 'fail',
     );
-    if (isFailure) {
+    // Non-watch runs let core's `finalizeRunCycle` own the exit code from the
+    // returned outcome; watch reruns set it here.
+    if (isWatchMode && isFailure) {
       ensureProcessExitCode(1);
     }
 
@@ -3376,10 +3474,12 @@ export const runBrowserController = async (
       hasFailure: isFailure,
       getSourcemap: getBrowserSourcemap,
       resolveSourcemap: resolveBrowserSourcemap,
-      close: skipOnTestRunEnd ? closeHeadlessRuntime : undefined,
+      // `closeHeadlessRuntime` is already `undefined` in watch mode, so the
+      // non-watch caller (core) receives the deferred close and watch does not.
+      close: closeHeadlessRuntime,
     };
 
-    if (!skipOnTestRunEnd) {
+    if (isWatchMode) {
       try {
         await notifyTestRunEnd({ duration });
       } finally {
@@ -3754,7 +3854,11 @@ export const runBrowserController = async (
       }
     } catch (error) {
       fatalError = fatalError ?? toError(error);
-      ensureProcessExitCode(1);
+      // Non-watch: the fatal error rides the returned outcome and core owns the
+      // exit code; watch reruns set it here.
+      if (isWatchMode) {
+        ensureProcessExitCode(1);
+      }
     }
 
     testTime = Date.now() - testStart;
@@ -3800,6 +3904,10 @@ export const runBrowserController = async (
             `Re-running ${rerunPlan.normalizedAffectedTestFiles.length} affected test file(s)...\n`,
           ),
         );
+        // Match the headless path: reset per-cycle state before the rerun
+        // streams new events, so bail counts and snapshot summaries do not
+        // accumulate across headed reruns.
+        prepareWatchRerunState(context);
         await notifyTestRunStart();
 
         const rerunStartTime = Date.now();
@@ -3874,7 +3982,9 @@ export const runBrowserController = async (
   const isFailure = reporterResults.some(
     (result: TestFileResult) => result.status === 'fail',
   );
-  if (isFailure) {
+  // Non-watch runs let core's `finalizeRunCycle` own the exit code from the
+  // returned outcome; watch reruns set it here.
+  if (isWatchMode && isFailure) {
     ensureProcessExitCode(1);
   }
 
@@ -3885,10 +3995,12 @@ export const runBrowserController = async (
     hasFailure: isFailure,
     getSourcemap: getBrowserSourcemap,
     resolveSourcemap: resolveBrowserSourcemap,
-    close: skipOnTestRunEnd ? closeContainerRuntime : undefined,
+    // `closeContainerRuntime` is already `undefined` in watch mode, so the
+    // non-watch caller (core) receives the deferred close and watch does not.
+    close: closeContainerRuntime,
   };
 
-  if (!skipOnTestRunEnd) {
+  if (isWatchMode) {
     try {
       await notifyTestRunEnd({ duration });
     } finally {
@@ -3926,20 +4038,20 @@ export type ListBrowserTestsResult = {
  */
 export const listBrowserTests = async (
   context: RstestContext,
-  options?: {
-    shardedEntries?: Map<string, { entries: Record<string, string> }>;
-  },
+  options?: ListBrowserTestsOptions,
 ): Promise<ListBrowserTestsResult> => {
+  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 (totalTests === 0) {
+  if (totalTests === 0 && !hasUserRstestConfigPlugins(browserProjects)) {
     return {
       list: [],
       close: async () => {},
@@ -3953,19 +4065,23 @@ export const listBrowserTests = async (
     `list-${Date.now()}`,
   );
 
-  const browserProjects = getBrowserProjects(context);
-
   // Create a simplified browser runtime for collect mode
   let runtime: BrowserRuntime;
   try {
     runtime = await createBrowserRuntime({
       context,
       projectEntries,
+      browserProjects,
+      shardedEntries: options?.shardedEntries,
+      freezeShardedEntries: options?.freezeShardedEntries,
       tempDir,
       isWatchMode: false,
       containerDistPath: undefined,
       containerDevServer: undefined,
       forceHeadless: true, // Always use headless for list command
+      skipProviderLaunch: options?.filesOnly,
+      appliedModifyRstestConfigEnvironments:
+        options?.appliedModifyRstestConfigEnvironments,
     });
   } catch (error) {
     const providers = [
@@ -3982,6 +4098,29 @@ export const listBrowserTests = async (
     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;
 
   // Get browser projects for runtime config
@@ -3991,17 +4130,14 @@ export const listBrowserTests = async (
       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,
     }),
   );
 
-  // Get max testTimeout from all browser projects for RPC timeout
-  const maxTestTimeoutForRpc = Math.max(
-    ...browserProjects.map(
-      (p) => p.normalizedConfig.testTimeout ?? DEFAULT_TEST_TIMEOUT,
-    ),
-  );
+  const maxTestTimeoutForRpc = getMaxTestTimeoutForRpc(browserProjects);
 
   const hostOptions: BrowserHostConfig = {
     rootPath: normalize(context.rootPath),
@@ -4026,6 +4162,10 @@ export const listBrowserTests = async (
 
   const serializedOptions = serializeForInlineScript(hostOptions);
 
+  // Per-page collect watchdog: a test file whose module evaluation stalls must
+  // not hang `rstest list` forever.
+  const collectTimeoutMs = 30_000;
+
   const collectFromServer = async (
     server: BrowserProjectServer,
   ): Promise<{ results: ListCommandResult[]; error: Error | null }> => {
@@ -4092,20 +4232,19 @@ export const listBrowserTests = async (
       waitUntil: 'load',
     });
 
-    // Wait for collection to complete with timeout
-    const timeoutMs = 30000;
+    // Wait for collection to complete with the shared collect timeout.
     let timeoutId: ReturnType<typeof setTimeout> | undefined;
     const timeoutPromise = new Promise<void>((resolve) => {
       timeoutId = setTimeout(() => {
         if (!collectCompleted) {
           logger.warn(
             color.yellow(
-              `[List] Browser test collection timed out after ${timeoutMs}ms`,
+              `[List] Browser test collection timed out after ${collectTimeoutMs}ms`,
             ),
           );
         }
         resolve();
-      }, timeoutMs);
+      }, collectTimeoutMs);
     });
 
     await Promise.race([collectPromise, timeoutPromise]);