@rstest/browser 0.11.5 → 0.11.7

package/src/hostController.ts

@@ -1,4633 +0,0 @@
-import { existsSync } from 'node:fs';
-import fs from 'node:fs/promises';
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { AddressInfo } from 'node:net';
-import { fileURLToPath } from 'node:url';
-import { isDeepStrictEqual } from 'node:util';
-import type { Rspack } from '@rstest/core';
-import {
-  applyWatchInvalidation,
-  applyWebMockRspackConfig,
-  type BrowserTestRunOptions,
-  type BrowserTestRunResult,
-  type BrowserWatchHandles,
-  buildBrowserCoverageMap,
-  type CoverageMapData,
-  type EntryHashSnapshot,
-  type ExecutorCycleOutcome,
-  FATAL_SIGNALS,
-  finalizeRunCycle,
-  type ListBrowserTestsOptions,
-  color,
-  createCoverageProvider,
-  createRunnerEventSink,
-  createSilentConsoleController,
-  DEFAULT_TEST_TIMEOUT,
-  type FormattedError,
-  getNoTestFilesMessage,
-  getPrettyConsoleName,
-  getSetupFiles,
-  getTestEntries,
-  hasUserRstestConfigPlugins,
-  importMetaRstestDefine,
-  initModifyRstestConfigHooks,
-  isDebug,
-  isTTY,
-  type ListCommandResult,
-  loadCoverageProvider,
-  logger,
-  logWatchReadyMessage,
-  pluginMockRuntime,
-  prepareWatchRerunState,
-  projectRuntimeConfig,
-  PhaseTracker,
-  type ProjectContext,
-  type Reporter,
-  type RunnerEventSink,
-  type RstestContext,
-  resolveProjectBuildCache,
-  resolveSnapshotPathDefault,
-  resolveShardedEntries,
-  RSTEST_ENV_SYMBOL_KEY,
-  rsbuild,
-  serializableConfig,
-  type Test,
-  type TestFileResult,
-  type TestResult,
-  type UserConsoleLog,
-  type WatchInvalidationState,
-} from '@rstest/core/internal/browser';
-import { type BirpcReturn, createBirpc } from 'birpc';
-import openEditor from 'open-editor';
-import { dirname, join, normalize, relative, resolve } from 'pathe';
-import picomatch from 'picomatch';
-import sirv from 'sirv';
-import { type WebSocket, WebSocketServer } from 'ws';
-import { getHeadlessConcurrency } from './concurrency';
-import {
-  createHostDispatchRouter,
-  type HostDispatchRouterOptions,
-} from './dispatchCapabilities';
-import { validateBrowserConfig } from './configValidation';
-import { createHeadedSerialTaskQueue } from './headedSerialTaskQueue';
-import { createHeadlessLatestRerunScheduler } from './headlessLatestRerunScheduler';
-import { attachHeadlessRunnerTransport } from './headlessTransport';
-import type {
-  BrowserClientMessage,
-  BrowserDispatchHandler,
-  BrowserDispatchRequest,
-  BrowserDispatchResponse,
-  BrowserHostConfig,
-  BrowserLogPayload,
-  BrowserProjectRuntime,
-  BrowserRpcRequest,
-  BrowserViewport,
-  SnapshotRpcRequest,
-  TestFileInfo,
-} from './protocol';
-import {
-  DISPATCH_MESSAGE_TYPE,
-  DISPATCH_NAMESPACE_BROWSER,
-  DISPATCH_NAMESPACE_RUNNER,
-  validateBrowserRpcRequest,
-} from './protocol';
-import {
-  type BrowserProvider,
-  type BrowserProviderBrowser,
-  type BrowserProviderContext,
-  type BrowserProviderImplementation,
-  type BrowserProviderPage,
-  getBrowserProviderImplementation,
-} from './providers';
-import {
-  createRunSession,
-  type RunSession,
-  RunSessionLifecycle,
-} from './runSession';
-import { RunnerSessionRegistry } from './sessionRegistry';
-import {
-  loadSourceMapWithCache,
-  normalizeJavaScriptUrl,
-  type SourceMapPayload,
-} from './sourceMap/sourceMapLoader';
-import { resolveBrowserViewportPreset } from './viewportPresets';
-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__';
-
-/**
- * Monotonic counter for synthetic per-file Perfetto `pid` values in `--trace`
- * mode. Browser host runs every test file inside the same Node process, so
- * without an override every file would emit events under the same `pid` and
- * share a single track labelled `worker <hostPid>`. Giving each file its own
- * synthetic `pid` makes the track title surface the file path instead,
- * matching node mode's default `isolate: true` behavior. The 1_000_000_000
- * base keeps each synthetic `pid` well clear of real OS `pid` values in
- * mixed-mode traces.
- */
-let nextBrowserFilePid = 1_000_000_000;
-
-/**
- * Serialize JSON for inline <script> injection.
- * Escapes '<' to prevent accidental </script> break-out.
- * Escapes U+2028/U+2029 to keep script parsing safe.
- */
-const serializeForInlineScript = (value: unknown): string => {
-  return JSON.stringify(value)
-    .replace(/</g, '\\u003c')
-    .replace(/\u2028/g, '\\u2028')
-    .replace(/\u2029/g, '\\u2029');
-};
-
-// ============================================================================
-// Type Definitions
-// ============================================================================
-
-type BrowserProjectEntries = {
-  project: ProjectContext;
-  setupFiles: string[];
-  testFiles: string[];
-};
-
-type BrowserProviderProject = {
-  rootPath: string;
-  provider: BrowserProvider;
-};
-
-type BrowserLaunchOptions = {
-  provider: BrowserProvider;
-  browser: ProjectContext['normalizedConfig']['browser']['browser'];
-  headless: ProjectContext['normalizedConfig']['browser']['headless'];
-  port: ProjectContext['normalizedConfig']['browser']['port'];
-  strictPort: ProjectContext['normalizedConfig']['browser']['strictPort'];
-  providerOptions: Record<string, unknown>;
-};
-
-const getBrowserProviderOptions = (
-  project: ProjectContext,
-): Record<string, unknown> => {
-  const browserConfig = project.normalizedConfig.browser as {
-    providerOptions?: Record<string, unknown>;
-  };
-
-  return browserConfig.providerOptions ?? {};
-};
-
-/** Payload for test file start event */
-type TestFileStartPayload = {
-  testPath: string;
-  projectName: string;
-};
-
-/** Payload for log event — single-sourced from the wire protocol. */
-type LogPayload = BrowserLogPayload;
-
-/** Payload for fatal error event */
-type FatalPayload = {
-  message: string;
-  stack?: string;
-};
-
-type ReporterHookArg<THook extends keyof Reporter> =
-  NonNullable<Reporter[THook]> extends (...args: infer TArgs) => unknown
-    ? TArgs[0]
-    : never;
-
-type TestFileReadyPayload = ReporterHookArg<'onTestFileReady'>;
-type TestSuiteStartPayload = ReporterHookArg<'onTestSuiteStart'>;
-type TestSuiteResultPayload = ReporterHookArg<'onTestSuiteResult'>;
-type TestCaseStartPayload = ReporterHookArg<'onTestCaseStart'>;
-type ReloadTestFileAck = {
-  runId: string;
-};
-type HeadedTestFileCompletePayload = TestFileResult & {
-  runId?: string;
-};
-
-type DeferredPromise<T> = {
-  promise: Promise<T>;
-  resolve: (value: T | PromiseLike<T>) => void;
-  reject: (reason?: unknown) => void;
-};
-
-const getFileTaskId = (testPath: string): string => {
-  return `file:${testPath}`;
-};
-
-const createDeferredPromise = <T>(): DeferredPromise<T> => {
-  let resolve!: DeferredPromise<T>['resolve'];
-  let reject!: DeferredPromise<T>['reject'];
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-
-  return {
-    promise,
-    resolve,
-    reject,
-  };
-};
-
-/** RPC methods exposed by the host (server) to the container (client) */
-type HostRpcMethods = {
-  rerunTest: (testFile: string, testNamePattern?: string) => Promise<void>;
-  getTestFiles: () => Promise<TestFileInfo[]>;
-  onRunnerFramesReady: (testFiles: string[]) => Promise<void>;
-  // Test result callbacks from container
-  onTestFileStart: (payload: TestFileStartPayload) => Promise<void>;
-  onTestCaseResult: (payload: TestResult) => Promise<void>;
-  onTestFileComplete: (payload: HeadedTestFileCompletePayload) => Promise<void>;
-  onLog: (payload: LogPayload) => Promise<void>;
-  onFatal: (payload: FatalPayload) => Promise<void>;
-  // Generic dispatch endpoint used by runner RPC requests.
-  dispatch: (
-    request: BrowserDispatchRequest,
-  ) => Promise<BrowserDispatchResponse>;
-};
-
-/** RPC methods exposed by the container (client) to the host (server) */
-type ContainerRpcMethods = {
-  onTestFileUpdate: (testFiles: TestFileInfo[]) => Promise<void>;
-  reloadTestFile: (
-    testFile: string,
-    testNamePattern?: string,
-  ) => Promise<ReloadTestFileAck>;
-  /**
-   * Replace the container's copy of the host config so runner iframes loaded
-   * from now on receive fresh values (e.g. the 'u' shortcut flipping
-   * `snapshot.updateSnapshot` between watch reruns).
-   */
-  onHostConfigUpdate: (config: BrowserHostConfig) => Promise<void>;
-};
-
-type ContainerRpc = BirpcReturn<ContainerRpcMethods, HostRpcMethods>;
-
-// ============================================================================
-// RPC Manager - Encapsulates WebSocket and birpc management
-// ============================================================================
-
-/**
- * Manages the WebSocket connection and birpc communication with the container UI.
- * Provides a clean interface for sending RPC calls and handling connections.
- */
-class ContainerRpcManager {
-  private wss: WebSocketServer;
-  private ws: WebSocket | null = null;
-  private rpc: ContainerRpc | null = null;
-  private methods: HostRpcMethods;
-  private onDisconnect?: (error: Error) => void;
-  private detachActiveSocketListeners: (() => void) | null = null;
-
-  constructor(
-    wss: WebSocketServer,
-    methods: HostRpcMethods,
-    onDisconnect?: (error: Error) => void,
-  ) {
-    this.wss = wss;
-    this.methods = methods;
-    this.onDisconnect = onDisconnect;
-    this.setupConnectionHandler();
-  }
-
-  /** Update the RPC methods (used when starting a new test run) */
-  updateMethods(
-    methods: HostRpcMethods,
-    onDisconnect?: (error: Error) => void,
-  ): void {
-    this.methods = methods;
-    this.onDisconnect = onDisconnect;
-    // Re-create birpc with new methods if already connected
-    if (this.ws && this.ws.readyState === this.ws.OPEN) {
-      this.attachWebSocket(this.ws);
-    }
-  }
-
-  private setupConnectionHandler(): void {
-    this.wss.on('connection', (ws: WebSocket) => {
-      logger.debug('[Browser UI] Container WebSocket connected');
-      logger.debug(
-        `[Browser UI] Current ws: ${this.ws ? 'exists' : 'null'}, new ws: ${ws ? 'exists' : 'null'}`,
-      );
-      this.attachWebSocket(ws);
-    });
-  }
-
-  private attachWebSocket(ws: WebSocket): void {
-    this.detachActiveSocketListeners?.();
-    if (this.rpc && !this.rpc.$closed) {
-      this.rpc.$close(new Error('Container RPC transport reattached'));
-    }
-    this.ws = ws;
-    const messageHandlers = new WeakMap<
-      (data: any) => void,
-      (message: any) => void
-    >();
-
-    this.rpc = createBirpc<ContainerRpcMethods, HostRpcMethods>(this.methods, {
-      timeout: -1,
-      post: (data) => {
-        if (ws.readyState === ws.OPEN) {
-          ws.send(JSON.stringify(data));
-        }
-      },
-      on: (fn) => {
-        const handler = (message: any) => {
-          try {
-            const data = JSON.parse(message.toString());
-            fn(data);
-          } catch {
-            // ignore invalid messages
-          }
-        };
-        messageHandlers.set(fn, handler);
-        ws.on('message', handler);
-      },
-      off: (fn) => {
-        const handler = messageHandlers.get(fn);
-        if (!handler) {
-          return;
-        }
-        ws.off('message', handler);
-        messageHandlers.delete(fn);
-      },
-    });
-
-    const handleClose = () => {
-      // Only clear if this is still the active connection
-      // This prevents a race condition when a new connection is established
-      // before the old one's close event fires
-      if (this.ws === ws) {
-        this.ws = null;
-      }
-      this.detachActiveSocketListeners?.();
-      this.detachActiveSocketListeners = null;
-      if (this.rpc && !this.rpc.$closed) {
-        const disconnectError = new Error(
-          'Browser UI WebSocket disconnected before reload completed',
-        );
-        this.rpc.$close(disconnectError);
-        this.onDisconnect?.(disconnectError);
-      }
-      this.rpc = null;
-    };
-
-    ws.on('close', handleClose);
-    this.detachActiveSocketListeners = () => {
-      ws.off('close', handleClose);
-    };
-  }
-
-  /** Check if a container is currently connected */
-  get isConnected(): boolean {
-    return this.ws !== null && this.ws.readyState === this.ws.OPEN;
-  }
-
-  /** Get the current WebSocket instance (for reuse in watch mode) */
-  get currentWebSocket(): WebSocket | null {
-    return this.ws;
-  }
-
-  /** Reattach an existing WebSocket (for watch mode reuse) */
-  reattach(ws: WebSocket): void {
-    this.attachWebSocket(ws);
-  }
-
-  /** Notify container of test file changes */
-  async notifyTestFileUpdate(files: TestFileInfo[]): Promise<void> {
-    await this.rpc?.onTestFileUpdate(files);
-  }
-
-  /** Push a refreshed host config to the container (watch reruns) */
-  async updateHostConfig(config: BrowserHostConfig): Promise<void> {
-    await this.rpc?.onHostConfigUpdate(config);
-  }
-
-  /** Request container to reload a specific test file */
-  async reloadTestFile(
-    testFile: string,
-    testNamePattern?: string,
-  ): Promise<ReloadTestFileAck> {
-    logger.debug(
-      `[Browser UI] reloadTestFile called, rpc: ${this.rpc ? 'exists' : 'null'}, ws: ${this.ws ? 'exists' : 'null'}`,
-    );
-    if (!this.rpc) {
-      throw new Error('Browser UI RPC not available for reloadTestFile');
-    }
-    logger.debug(`[Browser UI] Calling reloadTestFile: ${testFile}`);
-    return this.rpc.reloadTestFile(testFile, testNamePattern);
-  }
-}
-
-// ============================================================================
-// Browser Runtime - Core runtime state
-// ============================================================================
-
-// One isolated rsbuild instance + dev server per browser project. Physical
-// isolation (separate compiler, dev server, port, virtual manifest, runner)
-// prevents one project's build/resolve config from leaking into another's
-// compilation and avoids shared-dev-server races (chunk filenames,
-// lazyCompilation backend) between projects.
-type BrowserProjectServer = {
-  projectName: string;
-  environmentName: string;
-  rsbuildInstance: RsbuildInstance;
-  devServer: RsbuildDevServer;
-  port: number;
-  manifestPath: string;
-};
-
-// Watch diff/rerun state. Lives on the BrowserRuntime (one per set of
-// per-project compilers, surviving controller re-entry that reuses the
-// runtime) instead of module scope, so its lifetime always matches the
-// compilers whose baselines it holds.
-type BrowserWatchState = {
-  lastTestFiles: TestFileInfo[];
-  hooksEnabled: boolean;
-  // Diff baselines keyed per project: sibling projects have isolated
-  // compilers, so a shared flat baseline would let one project's compile
-  // clobber another's (missed reruns) and collide on compiler-local chunk
-  // keys.
-  invalidation: Map<string, WatchInvalidationState>;
-  // Affected files accumulated per project until a rerun drains them, so a
-  // compile finishing while another project's rerun is being planned cannot
-  // drop pending work.
-  pendingAffectedTestFiles: Map<string, Set<string>>;
-  // Per-project compile start times and the accumulated compile duration of
-  // the pending rerun, so the rerun's finalize reports the real buildTime.
-  compileStartTimes: Map<string, number>;
-  pendingBuildTimeMs: number;
-};
-
-const createBrowserWatchState = (): BrowserWatchState => ({
-  lastTestFiles: [],
-  hooksEnabled: false,
-  invalidation: new Map(),
-  pendingAffectedTestFiles: new Map(),
-  compileStartTimes: new Map(),
-  pendingBuildTimeMs: 0,
-});
-
-const drainPendingBuildTime = (watchState: BrowserWatchState): number => {
-  const buildTime = watchState.pendingBuildTimeMs;
-  watchState.pendingBuildTimeMs = 0;
-  return buildTime;
-};
-
-const drainPendingAffectedTestFiles = (
-  watchState: BrowserWatchState,
-): string[] => {
-  const affected = new Set<string>();
-  for (const files of watchState.pendingAffectedTestFiles.values()) {
-    for (const file of files) {
-      affected.add(file);
-    }
-  }
-  watchState.pendingAffectedTestFiles.clear();
-  return Array.from(affected);
-};
-
-type BrowserRuntime = {
-  // Per-project servers, keyed by project name.
-  projectServers: Map<string, BrowserProjectServer>;
-  // The server that hosts the container UI HTML (headed mode). The WebSocket
-  // server below is shared and reachable from any origin.
-  containerServer: BrowserProjectServer;
-  browser: BrowserProviderBrowser;
-  browserLaunchOptions: BrowserLaunchOptions;
-  wsPort: number;
-  tempDir: string;
-  containerPage?: BrowserProviderPage;
-  containerContext?: BrowserProviderContext;
-  setContainerOptions: (options: BrowserHostConfig) => void;
-  // Reserved extension seam for host-side dispatch capabilities.
-  dispatchHandlers: Map<string, BrowserDispatchHandler>;
-  wss: WebSocketServer;
-  rpcManager?: ContainerRpcManager;
-  projectEntries: BrowserProjectEntries[];
-  watchState: BrowserWatchState;
-};
-
-// ============================================================================
-// Watch Mode Context - Process-lifecycle watch state
-// ============================================================================
-
-// Only process-wide concerns stay module-level: the runtime handle reused
-// across controller re-entry (config-change restarts), and the signal/exit
-// cleanup that must run once per process. Diff/rerun state lives on
-// `BrowserRuntime.watchState`.
-type WatchContext = {
-  runtime: BrowserRuntime | null;
-  cleanupRegistered: boolean;
-  cleanupPromise: Promise<void> | null;
-};
-
-const watchContext: WatchContext = {
-  runtime: null,
-  cleanupRegistered: false,
-  cleanupPromise: null,
-};
-
-// ============================================================================
-// Utility Functions
-// ============================================================================
-
-const resolveViewport = (
-  viewport: BrowserViewport | undefined,
-): { width: number; height: number } | null => {
-  if (!viewport) {
-    return null;
-  }
-
-  if (typeof viewport === 'string') {
-    return resolveBrowserViewportPreset(viewport);
-  }
-
-  if (
-    typeof viewport.width === 'number' &&
-    Number.isFinite(viewport.width) &&
-    viewport.width > 0 &&
-    typeof viewport.height === 'number' &&
-    Number.isFinite(viewport.height) &&
-    viewport.height > 0
-  ) {
-    return {
-      width: viewport.width,
-      height: viewport.height,
-    };
-  }
-
-  return null;
-};
-
-const mapViewportByProject = (
-  projects: BrowserProjectRuntime[],
-): Map<string, { width: number; height: number }> => {
-  const map = new Map<string, { width: number; height: number }>();
-  for (const project of projects) {
-    const viewport = resolveViewport(project.viewport);
-    if (viewport) {
-      map.set(project.name, viewport);
-    }
-  }
-  return map;
-};
-
-const ensureProcessExitCode = (code: number): void => {
-  if (process.exitCode === undefined || process.exitCode === 0) {
-    process.exitCode = code;
-  }
-};
-
-const castArray = <T>(arr?: T | T[]): T[] => {
-  if (arr === undefined) {
-    return [];
-  }
-  return Array.isArray(arr) ? arr : [arr];
-};
-
-const applyDefaultWatchOptions = (
-  rspackConfig: Rspack.Configuration,
-  isWatchMode: boolean,
-) => {
-  rspackConfig.watchOptions ??= {};
-
-  if (!isWatchMode) {
-    rspackConfig.watchOptions.ignored = '**/**';
-    return;
-  }
-
-  rspackConfig.watchOptions.ignored = castArray(
-    rspackConfig.watchOptions.ignored || [],
-  ) as string[];
-
-  if (rspackConfig.watchOptions.ignored.length === 0) {
-    rspackConfig.watchOptions.ignored.push('**/.git', '**/node_modules');
-  }
-
-  if (rspackConfig.output?.path) {
-    rspackConfig.watchOptions.ignored.push(rspackConfig.output.path);
-  }
-};
-
-type LazyCompilationModule = {
-  nameForCondition?: () => string | null | undefined;
-};
-
-type BrowserLazyCompilationConfig = {
-  imports: true;
-  entries: false;
-  test?: (module: LazyCompilationModule) => boolean;
-};
-
-/**
- * Resolve the actual port the dev server is listening on.
- *
- * Rsbuild's `devServer.listen()` may return `0` when configured with
- * `server.port: 0` because its internal `getPort` never reads back the
- * OS-assigned ephemeral port.  This helper falls back to
- * `httpServer.address()` to obtain the real bound port.
- */
-export const resolveListenPort = (
-  listenPort: number,
-  httpServer: {
-    address: () => ReturnType<import('node:net').Server['address']>;
-  } | null,
-): number => {
-  if (listenPort) {
-    return listenPort;
-  }
-  const addr = httpServer?.address();
-  if (addr && typeof addr === 'object') {
-    return addr.port;
-  }
-  return listenPort;
-};
-
-export const createBrowserLazyCompilationConfig = (
-  setupFiles: string[],
-): BrowserLazyCompilationConfig => {
-  const eagerSetupFiles = new Set(
-    setupFiles.map((filePath) => normalize(filePath)),
-  );
-
-  if (eagerSetupFiles.size === 0) {
-    return {
-      imports: true,
-      entries: false,
-    };
-  }
-
-  return {
-    imports: true,
-    entries: false,
-    test(module: LazyCompilationModule) {
-      const filePath = module.nameForCondition?.();
-      return !filePath || !eagerSetupFiles.has(normalize(filePath));
-    },
-  };
-};
-
-/**
- * HMR — and the lazyCompilation transport it carries — is wired only for headed
- * watch, the sole path that reuses a persistent page and applies module updates
- * in place. Headless always loads each test file in a fresh page (pulling the
- * latest incrementally-built chunks over HTTP), and one-shot runs never rerun,
- * so pushing HMR updates there is dead weight that only races factory
- * registration for chunk-split node_modules (rspack#11922) and lets
- * lazyCompilation's accept-chain walk abort the next spec when no boundary
- * exists (#1472). Disabling HMR does not make watch rebuilds any less
- * incremental — HMR is only the client push transport.
- */
-export const shouldEnableBrowserHmr = (
-  isWatchMode: boolean,
-  isHeadless: boolean,
-): boolean => isWatchMode && !isHeadless;
-
-export const createBrowserRsbuildDevConfig = (
-  enableHmr: boolean,
-): {
-  writeToDisk: boolean;
-  hmr: boolean;
-  client: {
-    logLevel: 'error';
-  };
-} => {
-  return {
-    writeToDisk: isDebug(),
-    // `enableHmr` is gated to headed watch by `shouldEnableBrowserHmr` — the one
-    // path that reuses a page. See that helper for why fresh-page runs (headless,
-    // or any one-shot) must not receive HMR pushes.
-    hmr: enableHmr,
-    client: {
-      logLevel: 'error' as const,
-    },
-  };
-};
-
-/**
- * Convert a single glob pattern to RegExp using picomatch
- * Based on Storybook's implementation
- */
-const globToRegexp = (glob: string): RegExp => {
-  const regex = picomatch.makeRe(glob, {
-    fastpaths: false,
-    noglobstar: false,
-    bash: false,
-    dot: true,
-  });
-
-  if (!regex) {
-    throw new Error(`Invalid glob pattern: ${glob}`);
-  }
-
-  // picomatch generates regex starting with ^
-  // For patterns starting with ./, we need special handling
-  if (!glob.startsWith('./')) {
-    return regex;
-  }
-
-  // makeRe is sort of funny. If you pass it a directory starting with `./` it
-  // creates a matcher that expects files with no prefix (e.g. `src/file.js`)
-  // but if you pass it a directory that starts with `../` it expects files that
-  // start with `../`. Let's make it consistent.
-  // Globs starting `**` need special treatment due to the regex they produce
-  return new RegExp(
-    [
-      '^\\.',
-      glob.startsWith('./**') ? '' : '[\\\\/]',
-      regex.source.substring(1),
-    ].join(''),
-  );
-};
-
-/**
- * Convert rstest include glob patterns to RegExp for import.meta.webpackContext
- * Uses picomatch for robust glob-to-regexp conversion
- */
-const globPatternsToRegExp = (patterns: string[]): RegExp => {
-  const regexParts = patterns.map((pattern) => {
-    const regex = globToRegexp(pattern);
-    // Remove ^ anchor and $ anchor to allow combining patterns
-    let source = regex.source;
-    if (source.startsWith('^')) {
-      source = source.substring(1);
-    }
-    if (source.endsWith('$')) {
-      source = source.substring(0, source.length - 1);
-    }
-    return source;
-  });
-
-  return new RegExp(`(?:${regexParts.join('|')})$`);
-};
-
-const REGEXP_SPECIAL_CHARACTERS = /[|\\{}()[\]^$+*?.]/g;
-const PATH_SEPARATOR_SOURCE = String.raw`[\\/]`;
-const WINDOWS_ABSOLUTE_PATH_SOURCE = String.raw`[A-Za-z]:[\\/]`;
-
-const escapeRegExp = (value: string): string =>
-  value.replace(REGEXP_SPECIAL_CHARACTERS, '\\$&');
-
-const normalizePathForRegExp = (value: string): string =>
-  normalize(value).replaceAll('\\', '/');
-
-const normalizeExcludePatternForRegExp = (value: string): string =>
-  value.startsWith('./')
-    ? `./${normalizePathForRegExp(value.substring(2))}`
-    : normalizePathForRegExp(value);
-
-const isAbsolutePatternForRegExp = (value: string): boolean =>
-  value.startsWith('/') || /^[A-Za-z]:\//.test(value);
-
-const isEscapedRegExpCharacter = (source: string, index: number): boolean => {
-  let backslashCount = 0;
-  for (
-    let current = index - 1;
-    current >= 0 && source[current] === '\\';
-    current--
-  ) {
-    backslashCount++;
-  }
-  return backslashCount % 2 === 1;
-};
-
-const replacePathSeparatorsInRegExpSource = (source: string): string => {
-  let result = '';
-  let inCharacterClass = false;
-
-  for (let index = 0; index < source.length; index++) {
-    const character = source[index];
-    const isEscaped = isEscapedRegExpCharacter(source, index);
-
-    if (character === '[' && !isEscaped) {
-      inCharacterClass = true;
-    }
-
-    if (!inCharacterClass && character === '\\' && source[index + 1] === '/') {
-      result += PATH_SEPARATOR_SOURCE;
-      index++;
-      continue;
-    }
-
-    result += character;
-
-    if (character === ']' && !isEscaped) {
-      inCharacterClass = false;
-    }
-  }
-
-  return result;
-};
-
-type BrowserContextExcludeSource = {
-  relative: string;
-  absolute: string;
-  isAbsolute: boolean;
-};
-
-const createRelativeContextExcludeSource = (
-  source: string,
-  normalizedPattern: string,
-): string => {
-  if (normalizedPattern.startsWith('./')) {
-    return source;
-  }
-
-  return normalizedPattern.startsWith('**/')
-    ? `(?:(?:${source})|\\.(?:${source}))`
-    : `(?:(?:${source})|\\.${PATH_SEPARATOR_SOURCE}(?:${source}))`;
-};
-
-const createProjectAbsoluteExcludeSource = (
-  source: string,
-  normalizedPattern: string,
-): string =>
-  normalizedPattern.startsWith('./') || normalizedPattern.startsWith('**/')
-    ? source
-    : `${PATH_SEPARATOR_SOURCE}(?:${source})`;
-
-/**
- * Convert exclude patterns to a RegExp for import.meta.webpackContext's exclude option
- * This is used at compile time to filter out files during bundling
- *
- * Example:
- *   Input: ['**\/node_modules\/**', '**\/dist\/**']
- *   Output: a regexp matching node_modules or dist path segments.
- */
-const excludePatternsToRegExpSources = (
-  patterns: string[],
-): BrowserContextExcludeSource[] | null => {
-  const sources = patterns.map((pattern) => {
-    const normalizedPattern = normalizeExcludePatternForRegExp(pattern);
-    const regex = globToRegexp(normalizedPattern);
-    let source = regex.source;
-    if (source.startsWith('^')) {
-      source = source.substring(1);
-    }
-    if (source.endsWith('$')) {
-      source = source.substring(0, source.length - 1);
-    }
-
-    source = replacePathSeparatorsInRegExpSource(source);
-    const isAbsolute = isAbsolutePatternForRegExp(normalizedPattern);
-    const absolute = normalizedPattern.startsWith('./')
-      ? source.substring(2)
-      : source;
-
-    return {
-      relative: isAbsolute
-        ? source
-        : createRelativeContextExcludeSource(source, normalizedPattern),
-      absolute: isAbsolute
-        ? absolute
-        : createProjectAbsoluteExcludeSource(absolute, normalizedPattern),
-      isAbsolute,
-    };
-  });
-
-  if (sources.length === 0) {
-    return null;
-  }
-
-  return sources;
-};
-
-export const createBrowserContextExcludeRegExp = (
-  patterns: string[],
-  projectRoot: string,
-): RegExp | null => {
-  const excludeSources = excludePatternsToRegExpSources(patterns);
-  if (!excludeSources) {
-    return null;
-  }
-
-  const normalizedProjectRoot = normalizePathForRegExp(projectRoot).replace(
-    /[\\/]$/,
-    '',
-  );
-  const projectRootSource = normalizedProjectRoot
-    .split('/')
-    .map(escapeRegExp)
-    .join(PATH_SEPARATOR_SOURCE);
-  const relativeExcludeSources = excludeSources.filter(
-    (source) => !source.isAbsolute,
-  );
-  const absoluteExcludeSources = excludeSources.filter(
-    (source) => source.isAbsolute,
-  );
-  const sourceBranches: string[] = [];
-
-  if (relativeExcludeSources.length > 0) {
-    const relativePatternSource = `(?:${relativeExcludeSources
-      .map((source) => source.relative)
-      .join('|')})`;
-    const absolutePatternSource = `(?:${relativeExcludeSources
-      .map((source) => source.absolute)
-      .join('|')})`;
-    const relativeSource = `(?:${relativePatternSource})`;
-    const absoluteSource = normalizedProjectRoot
-      ? `${projectRootSource}(?=${PATH_SEPARATOR_SOURCE})(?:${absolutePatternSource})`
-      : `(?:${absolutePatternSource})`;
-
-    sourceBranches.push(
-      `(?!${WINDOWS_ABSOLUTE_PATH_SOURCE}|${PATH_SEPARATOR_SOURCE})${relativeSource}`,
-      absoluteSource,
-    );
-  }
-
-  if (absoluteExcludeSources.length > 0) {
-    sourceBranches.push(
-      `(?:${absoluteExcludeSources
-        .map((source) => source.relative)
-        .join('|')})`,
-    );
-  }
-
-  return new RegExp(`^(?:${sourceBranches.join('|')})$`);
-};
-
-type StatsModule = {
-  nameForCondition?: string;
-  children?: StatsModule[];
-};
-
-type StatsChunk = {
-  id?: string | number;
-  names?: string[];
-  hash?: string;
-  files?: string[];
-  modules?: StatsModule[];
-};
-
-/**
- * Find test file path from chunk modules by matching against known entry files.
- */
-const findTestFileInModules = (
-  modules: StatsModule[] | undefined,
-  entryTestFiles: Set<string>,
-): string | null => {
-  if (!modules) return null;
-
-  for (const m of modules) {
-    if (m.nameForCondition) {
-      const normalizedPath = normalize(m.nameForCondition);
-      if (entryTestFiles.has(normalizedPath)) {
-        return normalizedPath;
-      }
-    }
-    if (m.children) {
-      const found = findTestFileInModules(m.children, entryTestFiles);
-      if (found) return found;
-    }
-  }
-  return null;
-};
-
-/**
- * Get a stable identifier for a chunk.
- * Prefers chunk.id or chunk.names[0] over file paths for stability.
- */
-const getChunkKey = (chunk: StatsChunk): string | null => {
-  if (chunk.id != null) {
-    return String(chunk.id);
-  }
-  if (chunk.names && chunk.names.length > 0) {
-    return chunk.names[0]!;
-  }
-  if (chunk.files && chunk.files.length > 0) {
-    return chunk.files[0]!;
-  }
-  return null;
-};
-
-/**
- * Fold one project compile's chunks into per-entry hash snapshots and apply
- * the shared watch-invalidation policy against that project's baseline.
- * Chunks are attributed to a test/setup file by scanning their modules; the
- * chunk.id/names key is only the hash-record key, never a cross-project one.
- */
-const getAffectedTestFiles = ({
-  chunks,
-  entryTestFiles,
-  setupFiles,
-  state,
-}: {
-  chunks: StatsChunk[] | undefined;
-  entryTestFiles: Set<string>;
-  setupFiles: Set<string>;
-  state: WatchInvalidationState;
-}): string[] => {
-  const entryHashes: EntryHashSnapshot = new Map();
-  const setupHashes: EntryHashSnapshot = new Map();
-
-  const recordChunk = (
-    snapshot: EntryHashSnapshot,
-    entryPath: string,
-    chunkKey: string,
-    hash: string,
-  ) => {
-    const record = snapshot.get(entryPath) ?? {};
-    record[chunkKey] = hash;
-    snapshot.set(entryPath, record);
-  };
-
-  for (const chunk of chunks || []) {
-    if (!chunk.hash) continue;
-
-    const chunkKey = getChunkKey(chunk);
-    if (!chunkKey) continue;
-
-    const testFile = findTestFileInModules(chunk.modules, entryTestFiles);
-    if (testFile) {
-      recordChunk(entryHashes, testFile, chunkKey, chunk.hash);
-      continue;
-    }
-
-    const setupFile = findTestFileInModules(chunk.modules, setupFiles);
-    if (setupFile) {
-      recordChunk(setupHashes, setupFile, chunkKey, chunk.hash);
-    }
-  }
-
-  // Headed watch compiles chunks on demand (lazyCompilation), so an entry's
-  // first appearance in stats means "just loaded", not "just added": its first
-  // sighting establishes the baseline instead of marking a change. Genuinely
-  // new and deleted test files are owned by the test-file-set diff in
-  // `planWatchRerun` / `collectDeletedTestPaths`.
-  const seedFirstSeen = (
-    baseline: EntryHashSnapshot | undefined,
-    current: EntryHashSnapshot,
-  ) => {
-    if (!baseline) return;
-    for (const [entryPath, record] of current) {
-      if (!baseline.has(entryPath)) {
-        baseline.set(entryPath, record);
-      }
-    }
-  };
-  seedFirstSeen(state.entryHashes, entryHashes);
-  seedFirstSeen(state.setupHashes, setupHashes);
-
-  const outcome = applyWatchInvalidation(state, { entryHashes, setupHashes });
-
-  if (outcome.rerunAll) {
-    logger.debug(
-      '[Watch] Setup file changed, re-running all test files of the project',
-    );
-    return Array.from(entryTestFiles);
-  }
-
-  for (const affected of outcome.affectedPaths) {
-    logger.debug(`[Watch] Chunk hash changed for test: ${affected}`);
-  }
-
-  return outcome.affectedPaths;
-};
-
-const getBrowserProjects = (context: RstestContext): ProjectContext[] =>
-  context.projects.filter(
-    (project) => project.normalizedConfig.browser.enabled,
-  );
-
-const getBrowserRsbuildEnvironmentConfig = (
-  project: ProjectContext,
-): RsbuildEnvironmentConfig => ({
-  plugins: project.normalizedConfig.plugins,
-  root: project.rootPath,
-});
-
-// 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,
-): BrowserLaunchOptions => ({
-  provider: project.normalizedConfig.browser.provider,
-  browser: project.normalizedConfig.browser.browser,
-  headless: project.normalizedConfig.browser.headless,
-  port: project.normalizedConfig.browser.port,
-  strictPort: project.normalizedConfig.browser.strictPort,
-  providerOptions: getBrowserProviderOptions(project),
-});
-
-const ensureConsistentBrowserLaunchOptions = (
-  projects: ProjectContext[],
-): BrowserLaunchOptions => {
-  if (projects.length === 0) {
-    throw new Error('No browser-enabled projects found.');
-  }
-
-  const firstProject = projects[0]!;
-  const firstOptions = getBrowserLaunchOptions(firstProject);
-
-  for (const project of projects.slice(1)) {
-    const options = getBrowserLaunchOptions(project);
-    // Each browser project now runs on its own rsbuild dev server, so ports may
-    // differ per project. Only the shared single Playwright browser forces
-    // provider/browser/headless/providerOptions to match across projects.
-    if (
-      options.provider !== firstOptions.provider ||
-      options.browser !== firstOptions.browser ||
-      options.headless !== firstOptions.headless ||
-      !isDeepStrictEqual(options.providerOptions, firstOptions.providerOptions)
-    ) {
-      throw new Error(
-        `Browser launch config mismatch between projects "${firstProject.name}" and "${project.name}". ` +
-          'All browser-enabled projects in one run must share provider/browser/headless/providerOptions.',
-      );
-    }
-  }
-
-  return firstOptions;
-};
-
-const resolveProviderForTestPath = ({
-  testPath,
-  browserProjects,
-}: {
-  testPath: string;
-  browserProjects: BrowserProviderProject[];
-}): BrowserProvider => {
-  const normalizedTestPath = normalize(testPath);
-  const sortedProjects = [...browserProjects].sort(
-    (a, b) => b.rootPath.length - a.rootPath.length,
-  );
-
-  for (const project of sortedProjects) {
-    if (normalizedTestPath.startsWith(project.rootPath)) {
-      return project.provider;
-    }
-  }
-
-  throw new Error(
-    `Cannot resolve browser provider for test path: ${JSON.stringify(testPath)}. ` +
-      `Known project roots: ${JSON.stringify(sortedProjects.map((p) => p.rootPath))}`,
-  );
-};
-
-const collectProjectEntries = async (
-  context: 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[]> => {
-  return Promise.all(
-    browserProjects.map(async (project) => {
-      const {
-        normalizedConfig: { include, exclude, includeSource, setupFiles },
-      } = project;
-
-      const tests = await getTestEntries({
-        include,
-        exclude: exclude.patterns,
-        includeSource,
-        rootPath: context.rootPath,
-        projectRoot: project.rootPath,
-        fileFilters: context.fileFilters || [],
-        fileFilterMode: context.fileFilterMode,
-      });
-
-      const setup = getSetupFiles(setupFiles, project.rootPath);
-
-      return {
-        project,
-        setupFiles: Object.values(setup),
-        testFiles: Object.values(tests),
-      };
-    }),
-  );
-};
-
-const resolveBrowserFile = (relativePath: string): string => {
-  // __dirname points to packages/browser/dist when running from built code
-  // or packages/browser/src when running from source
-  const candidates = [
-    // When running from built dist: look in ../src for source files
-    resolve(__dirname, '../src', relativePath),
-    // When running from source (dev mode)
-    resolve(__dirname, relativePath),
-  ];
-
-  for (const candidate of candidates) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-
-  throw new Error(`Unable to resolve browser client file: ${relativePath}`);
-};
-
-const resolveContainerDist = (): string => {
-  // When running from built dist: browser-container is in the same dist folder
-  const distPath = resolve(__dirname, 'browser-container');
-  if (existsSync(distPath)) {
-    return distPath;
-  }
-
-  throw new Error(
-    `Browser container build not found at ${distPath}. Please run "pnpm --filter @rstest/browser build".`,
-  );
-};
-
-// ============================================================================
-// Manifest Generation
-// ============================================================================
-
-/**
- * Format environment name to a valid JavaScript identifier.
- * Replaces non-alphanumeric characters with underscores.
- */
-const toSafeVarName = (name: string): string => {
-  return name.replace(/[^a-zA-Z0-9_]/g, '_');
-};
-
-// Host-side mirror of the browser runtime's `toContextKey` (client/entry.ts):
-// `./<path-relative-to-project-root>` with forward slashes. The runtime derives
-// the same key from the target test file, so the non-watch import map below must
-// key by the identical form for `loadTest(key)` to resolve.
-export const toContextKey = (
-  filePath: string,
-  projectRootPosix: string,
-): string => {
-  const posixPath = normalize(filePath);
-  // Only strip the root at a path boundary: a bare `startsWith` would mangle a
-  // sibling like `/repo/pkg-extra/a.test.ts` under root `/repo/pkg`.
-  const withinRoot =
-    posixPath === projectRootPosix ||
-    posixPath.startsWith(`${projectRootPosix}/`);
-  if (!withinRoot) {
-    // Test file outside the project root: use the absolute path as the key so
-    // the runtime `toAbsolutePath` can round-trip it. A `./`-prefixed relative
-    // key would be re-rooted under projectRoot and point at a nonexistent file.
-    return posixPath;
-  }
-  const rel = posixPath.slice(projectRootPosix.length);
-  return rel.startsWith('/') ? `.${rel}` : `./${rel}`;
-};
-
-const generateManifestModule = ({
-  manifestPath,
-  entries,
-  isWatchMode,
-}: {
-  manifestPath: string;
-  entries: BrowserProjectEntries[];
-  isWatchMode: boolean;
-}): string => {
-  const manifestDirPosix = normalize(dirname(manifestPath));
-
-  const toRelativeImport = (filePath: string): string => {
-    const posixPath = normalize(filePath);
-    let relativePath = relative(manifestDirPosix, posixPath);
-    if (!relativePath.startsWith('.')) {
-      relativePath = `./${relativePath}`;
-    }
-    return relativePath;
-  };
-
-  const lines: string[] = [];
-
-  // 1. Export all projects configuration
-  lines.push('// All projects configuration');
-  lines.push('export const projects = [');
-  for (const { project } of entries) {
-    lines.push('  {');
-    lines.push(`    name: ${JSON.stringify(project.name)},`);
-    lines.push(
-      `    environmentName: ${JSON.stringify(project.environmentName)},`,
-    );
-    lines.push(
-      `    projectRoot: ${JSON.stringify(normalize(project.rootPath))},`,
-    );
-    lines.push('  },');
-  }
-  lines.push('];');
-  lines.push('');
-
-  // 2. Setup loaders for each project
-  lines.push('// Setup loaders for each project');
-  lines.push('export const projectSetupLoaders = {');
-  for (const { project, setupFiles } of entries) {
-    lines.push(`  ${JSON.stringify(project.name)}: [`);
-    for (const filePath of setupFiles) {
-      const relativePath = toRelativeImport(filePath);
-      lines.push(`    () => import(${JSON.stringify(relativePath)}),`);
-    }
-    lines.push('  ],');
-  }
-  lines.push('};');
-  lines.push('');
-
-  // 3. Test context for each project. Both branches expose the same shape as a
-  // webpackContext (callable by key, plus `keys()`), consumed in section 4.
-  lines.push('// Test context for each project');
-  for (const { project, testFiles } of entries) {
-    const varName = `context_${toSafeVarName(project.environmentName)}`;
-    const projectRootPosix = normalize(project.rootPath);
-
-    if (isWatchMode) {
-      // Watch mode keeps the include-glob context so newly added files are
-      // picked up on rebuild via `keys()` without regenerating the manifest.
-      // `mode: 'lazy'` is plain code-splitting (async chunks over HTTP), so it
-      // works with or without lazyCompilation; headed watch additionally layers
-      // lazyCompilation on top to keep the initial build cheap.
-      const includeRegExp = globPatternsToRegExp(
-        project.normalizedConfig.include,
-      );
-      const excludeRegExp = createBrowserContextExcludeRegExp(
-        project.normalizedConfig.exclude.patterns,
-        projectRootPosix,
-      );
-      const { includeSource } = project.normalizedConfig;
-      const emitContext = (contextVarName: string, regExp: RegExp): void => {
-        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 (includeSource.length === 0) {
-        emitContext(varName, includeRegExp);
-      } else {
-        // In-source test files (`includeSource`) carry an
-        // `if (import.meta.rstest)` block. The include context can't see them,
-        // so a second context over the `includeSource` globs backs
-        // host-scheduled loads, while `keys()` only unions the entry-probed
-        // in-source files (the probe does not apply inside the bundle, so raw
-        // source-context keys would execute never-probed files and fail with
-        // "No test suites found"). The probed list can go stale until a
-        // manifest refresh; scheduled-by-path loading never does.
-        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 {
-      // One-shot runs: the file set is fixed and already filtered, so emit an
-      // explicit lazy-import map (one chunk per literal `import()`, like the
-      // setup loaders above). The eager, non-lazyCompilation build then compiles
-      // only the run set instead of every included test file.
-      lines.push(`const ${varName}_modules = {`);
-      for (const filePath of testFiles) {
-        const key = toContextKey(filePath, projectRootPosix);
-        const importPath = toRelativeImport(filePath);
-        lines.push(
-          `  ${JSON.stringify(key)}: () => import(${JSON.stringify(importPath)}),`,
-        );
-      }
-      lines.push('};');
-      lines.push(
-        `const ${varName} = Object.assign((key) => ${varName}_modules[key](), {`,
-      );
-      lines.push(`  keys: () => Object.keys(${varName}_modules),`);
-      lines.push('});');
-    }
-    lines.push('');
-  }
-
-  // 4. Export test contexts object
-  lines.push('export const projectTestContexts = {');
-  for (const { project } of entries) {
-    const varName = `context_${toSafeVarName(project.environmentName)}`;
-    lines.push(`  ${JSON.stringify(project.name)}: {`);
-    lines.push(`    getTestKeys: () => ${varName}.keys(),`);
-    lines.push(`    loadTest: (key) => ${varName}(key),`);
-    lines.push(
-      `    projectRoot: ${JSON.stringify(normalize(project.rootPath))},`,
-    );
-    lines.push('  },');
-  }
-  lines.push('};');
-  lines.push('');
-
-  // 5. Backward compatibility exports (use first project as default)
-  lines.push('// Backward compatibility: export first project as default');
-  lines.push('export const projectConfig = projects[0];');
-  lines.push(
-    'export const setupLoaders = projectSetupLoaders[projects[0].name] || [];',
-  );
-  lines.push('const _defaultCtx = projectTestContexts[projects[0].name];');
-  lines.push(
-    'export const getTestKeys = () => _defaultCtx ? _defaultCtx.getTestKeys() : [];',
-  );
-  lines.push(
-    'export const loadTest = (key) => _defaultCtx ? _defaultCtx.loadTest(key) : Promise.reject(new Error("No project found"));',
-  );
-
-  return `${lines.join('\n')}\n`;
-};
-
-const htmlTemplate = `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <title>Rstest Browser Runner</title>
-  </head>
-  <body>
-    <script type="module" src="/static/js/runner.js"></script>
-  </body>
-</html>
-`;
-
-// Workaround for noisy "removed ..." logs caused by VirtualModulesPlugin.
-// Rsbuild suppresses the removed-file log if all removed paths include "virtual":
-// https://github.com/web-infra-dev/rsbuild/blob/1258fa9dba5c321a4629b591a6dadbd2e26c6963/packages/core/src/createCompiler.ts#L73-L76
-const VIRTUAL_MANIFEST_FILENAME = 'virtual-manifest.ts';
-
-// ============================================================================
-// Browser Runtime Lifecycle
-// ============================================================================
-
-const closeAllProjectServers = (
-  servers: Iterable<BrowserProjectServer>,
-): Promise<unknown> =>
-  Promise.allSettled([...servers].map((server) => server.devServer.close()));
-
-// Copy a proxied fetch Response's status + headers onto the Node response,
-// dropping content-length (the body is re-sent, so the original length may not
-// match).
-const copyProxyResponseHeaders = (
-  response: Response,
-  res: ServerResponse,
-): void => {
-  res.statusCode = response.status;
-  response.headers.forEach((value, key) => {
-    if (key.toLowerCase() === 'content-length') {
-      return;
-    }
-    res.setHeader(key, value);
-  });
-};
-
-const destroyBrowserRuntime = async (
-  runtime: BrowserRuntime,
-): Promise<void> => {
-  try {
-    await runtime.browser?.close?.();
-  } catch {
-    // ignore
-  }
-  await closeAllProjectServers(runtime.projectServers.values());
-  try {
-    runtime.wss?.close();
-  } catch {
-    // ignore
-  }
-  await fs
-    .rm(runtime.tempDir, { recursive: true, force: true })
-    .catch(() => {});
-};
-
-const cleanupWatchRuntime = (): Promise<void> => {
-  if (watchContext.cleanupPromise) {
-    return watchContext.cleanupPromise;
-  }
-
-  watchContext.cleanupPromise = (async () => {
-    if (!watchContext.runtime) {
-      return;
-    }
-
-    await destroyBrowserRuntime(watchContext.runtime);
-    watchContext.runtime = null;
-  })();
-
-  return watchContext.cleanupPromise;
-};
-
-const registerWatchCleanup = (embedded: boolean): void => {
-  if (watchContext.cleanupRegistered) {
-    return;
-  }
-  watchContext.cleanupRegistered = true;
-
-  // Embedded (programmatic) hosts own the process lifecycle; they tear the
-  // session down through the watch handles' `close` instead of signals.
-  if (embedded) {
-    return;
-  }
-
-  // Cleanup-only nets: core's watch loop owns the signal → exit-code path
-  // (`registerBrowserWatchSignalExit` / the mixed watch handler) and awaits
-  // the same idempotent `cleanupWatchRuntime` promise through `watch.close`.
-  for (const signal of FATAL_SIGNALS) {
-    process.once(signal, () => {
-      void cleanupWatchRuntime();
-    });
-  }
-
-  process.once('exit', () => {
-    void cleanupWatchRuntime();
-  });
-};
-
-const createBrowserRuntime = async ({
-  context,
-  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>;
-  containerDistPath?: string;
-  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
-    ? await fs.readFile(join(containerDistPath, 'index.html'), 'utf-8')
-    : null;
-
-  let injectedContainerHtml: string | null = null;
-  let serializedOptions = 'null';
-  // Reserved extension seam for future browser-side capabilities.
-  const dispatchHandlers = new Map<string, BrowserDispatchHandler>();
-
-  const setContainerOptions = (options: BrowserHostConfig): void => {
-    serializedOptions = serializeForInlineScript(options);
-    if (containerHtmlTemplate) {
-      injectedContainerHtml = containerHtmlTemplate.replace(
-        OPTIONS_PLACEHOLDER,
-        serializedOptions,
-      );
-    }
-  };
-
-  let browserLaunchOptions =
-    ensureConsistentBrowserLaunchOptions(browserProjects);
-  let projectEntries = initialProjectEntries;
-  // Created with the runtime so the per-project watch plugins and the
-  // controller's rerun closures share one state whose lifetime matches the
-  // compilers holding the diffed chunks.
-  const watchState = createBrowserWatchState();
-  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,
-      watchState,
-    };
-  };
-
-  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(
-    import.meta.resolve('@rstest/core/internal/browser-runtime'),
-  );
-
-  // Shared by every project — only the per-project `@rstest/browser-manifest`
-  // alias varies (one virtual manifest per server).
-  const staticRstestAliases = {
-    // User test code `import { describe, it } from '@rstest/core'` is NOT
-    // aliased: `applyWebMockRspackConfig` keeps the request external against
-    // `globalThis['@rstest/core']` (node parity), which also keeps the mock
-    // hoister's provider-import ordering correct for `rs.hoisted` callbacks.
-    // User test code: import { page } from '@rstest/browser'
-    '@rstest/browser': resolveBrowserFile('browser.ts'),
-    // Browser runtime APIs for entry.ts
-    // Uses dist file with extractSourceMap to preserve sourcemap chain for inline snapshots
-    '@rstest/core/internal/browser-runtime': browserRuntimePath,
-  };
-
-  // rspack `define` replaces `process.env` / `import.meta.env` with this literal
-  // expression. JSON.stringify reproduces the exact double-quoted `"rstest.env"`
-  // text, so the owned key can never drift from the runtime
-  // `Symbol.for(RSTEST_ENV_SYMBOL_KEY)` sites.
-  const rstestEnvDefine = `globalThis[Symbol.for(${JSON.stringify(
-    RSTEST_ENV_SYMBOL_KEY,
-  )})]`;
-
-  // Serve prebuilt container assets (SPA) via sirv (container origin only)
-  const serveContainer = containerDistPath
-    ? sirv(containerDistPath, {
-        dev: false,
-        single: 'index.html',
-      })
-    : null;
-
-  const containerDevBase = containerDevServer
-    ? new URL(containerDevServer)
-    : null;
-
-  const respondWithDevServerHtml = async (
-    url: URL,
-    res: ServerResponse,
-  ): Promise<boolean> => {
-    if (!containerDevBase) {
-      return false;
-    }
-
-    try {
-      const target = new URL(url.pathname + url.search, containerDevBase);
-      const response = await fetch(target);
-      if (!response.ok) {
-        return false;
-      }
-
-      let html = await response.text();
-      html = html.replace(OPTIONS_PLACEHOLDER, serializedOptions);
-
-      copyProxyResponseHeaders(response, res);
-      res.setHeader('Content-Type', 'text/html');
-      res.end(html);
-      return true;
-    } catch (error) {
-      logger.debug(
-        `[Browser UI] Failed to fetch container HTML from dev server: ${String(error)}`,
-      );
-      return false;
-    }
-  };
-
-  const proxyDevServerAsset = async (
-    req: IncomingMessage,
-    res: ServerResponse,
-  ): Promise<boolean> => {
-    if (!containerDevBase || !req.url) {
-      return false;
-    }
-
-    try {
-      const target = new URL(req.url, containerDevBase);
-      const response = await fetch(target);
-      if (!response.ok) {
-        return false;
-      }
-
-      const buffer = Buffer.from(await response.arrayBuffer());
-      copyProxyResponseHeaders(response, res);
-      res.end(buffer);
-      return true;
-    } catch (error) {
-      logger.debug(
-        `[Browser UI] Failed to proxy asset from dev server: ${String(error)}`,
-      );
-      return false;
-    }
-  };
-
-  const serveContainerRoute = async (
-    req: IncomingMessage,
-    res: ServerResponse,
-    next: () => void,
-  ): Promise<void> => {
-    if (!req.url) {
-      next();
-      return;
-    }
-
-    const url = new URL(req.url, 'http://localhost');
-    if (url.pathname === '/') {
-      if (await respondWithDevServerHtml(url, res)) {
-        return;
-      }
-
-      const html =
-        injectedContainerHtml ||
-        containerHtmlTemplate?.replace(OPTIONS_PLACEHOLDER, 'null');
-
-      if (html) {
-        res.setHeader('Content-Type', 'text/html');
-        res.end(html);
-        return;
-      }
-
-      res.statusCode = 502;
-      res.end('Container UI is not available.');
-      return;
-    }
-
-    if (url.pathname.startsWith('/container-static/')) {
-      if (await proxyDevServerAsset(req, res)) {
-        return;
-      }
-
-      if (serveContainer) {
-        serveContainer(req, res, next);
-        return;
-      }
-
-      res.statusCode = 502;
-      res.end('Container assets are not available.');
-      return;
-    }
-
-    next();
-  };
-
-  // ---- Build one isolated rsbuild instance + dev server per project ----
-  const buildProjectServer = async (
-    project: ProjectContext,
-    isContainerServer: boolean,
-  ): Promise<BrowserProjectServer> => {
-    const manifestPath = join(
-      tempDir,
-      toSafeVarName(project.environmentName),
-      VIRTUAL_MANIFEST_FILENAME,
-    );
-    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,
-      project,
-      modules: virtualManifestModules,
-    });
-
-    const rstestInternalAliases = {
-      '@rstest/browser-manifest': manifestPath,
-      ...staticRstestAliases,
-    };
-
-    const isHeadless =
-      forceHeadless || project.normalizedConfig.browser.headless;
-    const enableHmr = shouldEnableBrowserHmr(isWatchMode, isHeadless);
-
-    const rsbuildInstance = await createRsbuild({
-      callerName: 'rstest',
-      rsbuildConfig: {
-        root: context.rootPath,
-        mode: 'development',
-        server: {
-          printUrls: false,
-          // Each project gets its own dev server. Honor an explicitly
-          // configured port; otherwise keep the historical 4000 default for the
-          // container server and let the OS assign free ports for the rest, so
-          // multiple projects never collide on one port.
-          port:
-            project.normalizedConfig.browser.port ??
-            (isContainerServer ? 4000 : 0),
-          strictPort: project.normalizedConfig.browser.strictPort,
-          // User plugins may emit index.html; register before Rsbuild's HTML
-          // completion middleware so `/` remains owned by the Browser UI.
-          setup: isContainerServer
-            ? ({ server }) => {
-                server.middlewares.use(serveContainerRoute);
-              }
-            : undefined,
-        },
-        dev: createBrowserRsbuildDevConfig(enableHmr),
-        environments: {
-          [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([
-      // Same mock runtime as the node build (importActual doppelganger rule +
-      // mock webpack runtime module); order-insensitive and self-contained.
-      pluginMockRuntime,
-      {
-        name: 'rstest:browser-user-config',
-        setup(api) {
-          // Internal extension entry: register host dispatch handlers without
-          // coupling scheduling to individual capability implementations.
-          (api as { expose?: (name: string, value: unknown) => void }).expose?.(
-            'rstest:browser',
-            {
-              registerDispatchHandler: (
-                namespace: string,
-                handler: BrowserDispatchHandler,
-              ) => {
-                dispatchHandlers.set(namespace, handler);
-              },
-            },
-          );
-
-          api.modifyEnvironmentConfig({
-            handler: (config, { mergeEnvironmentConfig, name }) => {
-              if (name !== project.environmentName) {
-                return config;
-              }
-
-              const userRsbuildConfig = project.normalizedConfig;
-              const buildCache = resolveProjectBuildCache({
-                context,
-                project,
-              });
-              const setupFiles = Object.values(
-                getSetupFiles(
-                  project.normalizedConfig.setupFiles,
-                  project.rootPath,
-                ),
-              );
-              // Merge order: current config -> userConfig -> rstest required config (highest priority)
-              const merged = mergeEnvironmentConfig(
-                config,
-                {
-                  ...userRsbuildConfig,
-                  performance: buildCache
-                    ? {
-                        ...userRsbuildConfig.performance,
-                        buildCache,
-                      }
-                    : userRsbuildConfig.performance,
-                },
-                {
-                  resolve: {
-                    alias: rstestInternalAliases,
-                  },
-                  source: {
-                    define: {
-                      'process.env': rstestEnvDefine,
-                      'import.meta.env': rstestEnvDefine,
-                      // In-source `if (import.meta.rstest)` blocks read the
-                      // per-file runtime API the client entry publishes on
-                      // `globalThis` (node parity: `global['@rstest/core']`).
-                      'import.meta.rstest': importMetaRstestDefine('web'),
-                    },
-                  },
-                  output: {
-                    target: 'web',
-                    // Enable source map for inline snapshot support
-                    sourceMap: {
-                      js: 'source-map',
-                    },
-                    // Every project server compiles the same asset names
-                    // (`static/js/runner.js`, ...). With `dev.writeToDisk`
-                    // (debug mode) the middleware serves from disk, so a
-                    // shared dist dir would be last-writer-wins and one
-                    // project's server would deliver another project's
-                    // bundle — keep each project's output isolated, inside
-                    // the run's temp dir so teardown removes it.
-                    distPath: {
-                      root: join(
-                        tempDir,
-                        'server',
-                        toSafeVarName(project.environmentName),
-                      ),
-                    },
-                  },
-                  tools: {
-                    swc: (swcConfig) => {
-                      // Fixture dependency discovery reads callback parameters
-                      // through Function#toString(). Playwright's supported
-                      // browsers all support parameter destructuring, so keep
-                      // that syntax intact in the browser test bundle.
-                      swcConfig.env ??= {};
-                      swcConfig.env.exclude = Array.from(
-                        new Set([
-                          ...(swcConfig.env.exclude ?? []),
-                          'transform-parameters',
-                        ]),
-                      );
-                    },
-                    rspack: (rspackConfig) => {
-                      rspackConfig.mode = 'development';
-                      // Web parameterization of the node mock transform:
-                      // RstestPlugin (hoist + path injection), the
-                      // `@rstest/core` global external, and
-                      // `exportsPresence: 'warn'`.
-                      applyWebMockRspackConfig(rspackConfig, {
-                        rspack,
-                        rootPath: project.rootPath,
-                      });
-                      // lazyCompilation's only delivery transport is the HMR
-                      // runtime, so it follows the same gate as HMR (see
-                      // `shouldEnableBrowserHmr`): headed watch only, everything
-                      // else compiles eagerly.
-                      rspackConfig.lazyCompilation = enableHmr
-                        ? createBrowserLazyCompilationConfig(setupFiles)
-                        : false;
-                      rspackConfig.plugins = rspackConfig.plugins || [];
-                      rspackConfig.plugins.push(virtualManifestPlugin);
-
-                      applyDefaultWatchOptions(rspackConfig, isWatchMode);
-
-                      // Extract and merge sourcemaps from pre-built @rstest/core files
-                      // This preserves the sourcemap chain for inline snapshot support
-                      // See: https://rspack.rs/config/module-rules#rulesextractsourcemap
-                      const browserRuntimeDir = dirname(browserRuntimePath);
-                      rspackConfig.module = rspackConfig.module || {};
-                      rspackConfig.module.rules =
-                        rspackConfig.module.rules || [];
-                      rspackConfig.module.rules.unshift({
-                        test: /\.js$/,
-                        include: browserRuntimeDir,
-                        extractSourceMap: true,
-                      });
-
-                      if (isDebug()) {
-                        logger.log(
-                          `[rstest:browser] extractSourceMap rule added for: ${browserRuntimeDir}`,
-                        );
-                      }
-                    },
-                  },
-                },
-              );
-
-              // Completely overwrite entry to prevent Rsbuild default entry detection from taking effect.
-              // In browser mode, entry is fully controlled by rstest (not user's src/index.ts).
-              // This must be done after mergeEnvironmentConfig to ensure highest priority.
-              merged.source = merged.source || {};
-              merged.source.entry = {
-                runner: resolveBrowserFile('client/entry.ts'),
-              };
-
-              return merged;
-            },
-            // Execute after all other plugins to ensure rstest's entry config has the highest priority
-            order: 'post',
-          });
-        },
-      },
-    ]);
-
-    // Register watch plugin if in watch mode
-    if (isWatchMode && onTriggerRerun) {
-      rsbuildInstance.addPlugins([
-        {
-          name: 'rstest:browser-watch',
-          setup(api) {
-            api.onBeforeDevCompile(() => {
-              watchState.compileStartTimes.set(project.name, Date.now());
-              if (!watchState.hooksEnabled) {
-                return;
-              }
-              logger.log(color.cyan('\nFile changed, re-running tests...\n'));
-            });
-
-            api.onAfterDevCompile(async ({ stats }) => {
-              const compileStart = watchState.compileStartTimes.get(
-                project.name,
-              );
-              if (compileStart !== undefined) {
-                watchState.compileStartTimes.delete(project.name);
-                // Only change-triggered compiles feed the pending rerun's
-                // build phase (the initial build is the initial run's
-                // buildTime). Parallel project compiles overlap; the longest
-                // one bounds the rerun's build phase.
-                if (watchState.hooksEnabled) {
-                  watchState.pendingBuildTimeMs = Math.max(
-                    watchState.pendingBuildTimeMs,
-                    Date.now() - compileStart,
-                  );
-                }
-              }
-              // Collect hashes even during initial build to establish baseline
-              if (stats) {
-                // This compiler only ever holds this project's entries; the
-                // diff baseline is keyed per project accordingly.
-                const [projectEntry] = await collectProjectEntries(context, [
-                  project,
-                ]);
-                const entryTestFiles = new Set<string>(
-                  collectWatchTestFiles(projectEntry ? [projectEntry] : []).map(
-                    (file) => file.testPath,
-                  ),
-                );
-                const setupFiles = new Set<string>(
-                  (projectEntry?.setupFiles ?? []).map((file) =>
-                    normalize(file),
-                  ),
-                );
-
-                let state = watchState.invalidation.get(project.name);
-                if (!state) {
-                  state = {};
-                  watchState.invalidation.set(project.name, state);
-                }
-
-                const statsJson = stats.toJson({ all: true });
-                const affected = getAffectedTestFiles({
-                  chunks: statsJson.chunks,
-                  entryTestFiles,
-                  setupFiles,
-                  state,
-                });
-
-                if (affected.length > 0) {
-                  const pending =
-                    watchState.pendingAffectedTestFiles.get(project.name) ??
-                    new Set<string>();
-                  for (const file of affected) {
-                    pending.add(file);
-                  }
-                  watchState.pendingAffectedTestFiles.set(
-                    project.name,
-                    pending,
-                  );
-                  logger.debug(
-                    `[Watch] Affected test files: ${affected.join(', ')}`,
-                  );
-                }
-              }
-
-              if (!watchState.hooksEnabled) {
-                return;
-              }
-
-              await onTriggerRerun();
-            });
-          },
-        },
-      ]);
-    }
-
-    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') {
-      const { pluginCoverage } = await loadCoverageProvider(
-        coverage,
-        context.rootPath,
-      );
-      rsbuildInstance.addPlugins([pluginCoverage(coverage)]);
-    }
-
-    const devServer = await rsbuildInstance.createDevServer({
-      getPortSilently: true,
-    });
-
-    if (isDebug()) {
-      await rsbuildInstance.inspectConfig({
-        writeToDisk: true,
-        // The server's own distPath is isolated per project inside the run's
-        // temp dir (removed at teardown); keep the debug artifacts at the
-        // project's stable dist root so they survive the run and stay where
-        // the docs point users to.
-        outputPath: resolve(
-          context.rootPath,
-          context.normalizedConfig.output.distPath.root,
-          '.rsbuild',
-        ),
-        extraConfigs: {
-          rstest: {
-            ...context.normalizedConfig,
-            projects: [project.normalizedConfig],
-          },
-        },
-      });
-    }
-
-    devServer.middlewares.use(
-      async (req: IncomingMessage, res: ServerResponse, next: () => void) => {
-        if (!req.url) {
-          next();
-          return;
-        }
-        const url = new URL(req.url, 'http://localhost');
-        if (url.pathname === '/__open-in-editor') {
-          const file = url.searchParams.get('file');
-          if (!file) {
-            res.statusCode = 400;
-            res.end('Missing file');
-            return;
-          }
-          try {
-            await openEditor([{ file }]);
-            res.statusCode = 204;
-            res.end();
-          } catch (error) {
-            logger.debug(
-              `[Browser UI] Failed to open editor: ${String(error)}`,
-            );
-            res.statusCode = 500;
-            res.end('Failed to open editor');
-          }
-          return;
-        }
-        if (url.pathname === '/runner.html') {
-          res.setHeader('Content-Type', 'text/html');
-          res.end(htmlTemplate);
-          return;
-        }
-        next();
-      },
-    );
-
-    const { port: listenPort } = await devServer.listen();
-    const port = resolveListenPort(listenPort, devServer.httpServer);
-
-    return {
-      projectName: project.name,
-      environmentName: project.environmentName,
-      rsbuildInstance,
-      devServer,
-      port,
-      manifestPath,
-    };
-  };
-
-  // Build each project's server sequentially. Servers must bind ports one at a
-  // time: projects may share a configured port and rely on strictPort:false
-  // bumping to the next free one, which races under concurrent listen().
-  const projectServers = new Map<string, BrowserProjectServer>();
-  try {
-    for (const [index, project] of browserProjects.entries()) {
-      const server = await buildProjectServer(project, index === 0);
-      projectServers.set(server.projectName, server);
-    }
-  } catch (error) {
-    await closeAllProjectServers(projectServers.values());
-    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)!;
-
-  // Create WebSocket server on an available port
-  // Using port: 0 lets the OS assign an available port, avoiding conflicts
-  // when the fixed port (e.g., container port + 1) is already in use
-  const wss = new WebSocketServer({ port: 0 });
-  await new Promise<void>((resolve, reject) => {
-    wss.once('listening', resolve);
-    wss.once('error', reject);
-  });
-  const wsPort = (wss.address() as AddressInfo).port;
-  logger.debug(`[Browser UI] WebSocket server started on port ${wsPort}`);
-
-  const browserName = browserLaunchOptions.browser ?? 'chromium';
-  try {
-    const providerImplementation = getBrowserProviderImplementation(
-      browserLaunchOptions.provider,
-    );
-    const runtime = await providerImplementation.launchRuntime({
-      browserName,
-      headless: forceHeadless ?? browserLaunchOptions.headless,
-      providerOptions: browserLaunchOptions.providerOptions,
-    });
-    return {
-      projectServers,
-      containerServer,
-      browser: runtime.browser,
-      browserLaunchOptions,
-      wsPort,
-      tempDir,
-      setContainerOptions,
-      dispatchHandlers,
-      wss,
-      projectEntries,
-      watchState,
-    };
-  } catch (error) {
-    wss.close();
-    await closeAllProjectServers(projectServers.values());
-    throw error;
-  }
-};
-
-async function resolveProjectEntries(
-  context: RstestContext,
-  shardedEntries: Map<string, { entries: Record<string, string> }> | undefined,
-  browserProjects: ProjectContext[],
-): Promise<BrowserProjectEntries[]> {
-  if (shardedEntries) {
-    const projectEntries: BrowserProjectEntries[] = [];
-    for (const project of browserProjects) {
-      const entryInfo = shardedEntries.get(project.environmentName);
-      if (entryInfo && Object.keys(entryInfo.entries).length > 0) {
-        const setup = getSetupFiles(
-          project.normalizedConfig.setupFiles,
-          project.rootPath,
-        );
-        projectEntries.push({
-          project,
-          setupFiles: Object.values(setup),
-          testFiles: Object.values(entryInfo.entries),
-        });
-      }
-    }
-    return projectEntries;
-  }
-  return collectProjectEntries(context, browserProjects);
-}
-
-// ============================================================================
-// Main Entry Point
-// ============================================================================
-
-export const runBrowserController = async (
-  context: RstestContext,
-  options?: BrowserTestRunOptions,
-): Promise<BrowserTestRunResult | void> => {
-  const {
-    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
-  // passes `onTraceEvents`). The browser host shares one Node process across
-  // every test file, so each tracker is assigned a synthetic per-file pid
-  // (`nextBrowserFilePid`) that lets Perfetto render each file as its own
-  // process track with the file path as the title. Keyed by project + path so
-  // concurrent projects running the same file keep separate trackers.
-  const phaseTrackers = onTraceEvents
-    ? new Map<string, PhaseTracker>()
-    : undefined;
-  const trackerKey = (project: string, testPath: string) =>
-    `${project}\u0000${testPath}`;
-  // 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,
-  );
-
-  const browserSourceMapCache = new Map<string, SourceMapPayload | null>();
-
-  const isHttpLikeFile = (file: string): boolean => /^https?:\/\//.test(file);
-
-  const resolveBrowserSourcemap = async (sourcePath: string) => {
-    if (!isHttpLikeFile(sourcePath)) {
-      return {
-        handled: false,
-        sourcemap: null,
-      };
-    }
-
-    const normalizedUrl = normalizeJavaScriptUrl(sourcePath);
-    if (!normalizedUrl) {
-      return {
-        handled: true,
-        sourcemap: null,
-      };
-    }
-
-    if (browserSourceMapCache.has(normalizedUrl)) {
-      return {
-        handled: true,
-        sourcemap: browserSourceMapCache.get(normalizedUrl) ?? null,
-      };
-    }
-
-    return {
-      handled: true,
-      sourcemap: await loadSourceMapWithCache({
-        jsUrl: normalizedUrl,
-        cache: browserSourceMapCache,
-      }),
-    };
-  };
-
-  const getBrowserSourcemap = async (
-    sourcePath: string,
-  ): Promise<SourceMapPayload | null> => {
-    const result = await resolveBrowserSourcemap(sourcePath);
-    return result.handled ? result.sourcemap : null;
-  };
-
-  /**
-   * Build an error BrowserTestRunResult and call onTestRunEnd if needed.
-   * Used for early-exit error paths to ensure errors reach the summary report.
-   */
-  const buildErrorResult = async (
-    error: Error,
-    close?: () => Promise<void>,
-  ): Promise<BrowserTestRunResult> => {
-    const elapsed = Math.max(0, Date.now() - buildStart);
-    const errorResult = {
-      results: [],
-      testResults: [],
-      duration: { totalTime: elapsed, buildTime: elapsed, testTime: 0 },
-      hasFailure: true,
-      unhandledErrors: [error],
-      getSourcemap: getBrowserSourcemap,
-      resolveSourcemap: resolveBrowserSourcemap,
-      close,
-    };
-
-    if (isWatchMode) {
-      for (const reporter of context.reporters) {
-        await (reporter as Reporter).onTestRunEnd?.({
-          results: [],
-          testResults: [],
-          duration: errorResult.duration,
-          snapshotSummary: context.snapshotManager.summary,
-          getSourcemap: getBrowserSourcemap,
-          unhandledErrors: errorResult.unhandledErrors,
-        });
-      }
-    }
-
-    return errorResult;
-  };
-
-  const toError = (error: unknown): Error => {
-    return error instanceof Error ? error : new Error(String(error));
-  };
-
-  const failWithError = async (
-    error: unknown,
-    cleanup?: () => Promise<void>,
-  ): Promise<BrowserTestRunResult> => {
-    // 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 && !isWatchMode) {
-      return buildErrorResult(normalizedError, cleanup);
-    }
-
-    try {
-      return await buildErrorResult(normalizedError);
-    } finally {
-      await cleanup?.();
-    }
-  };
-
-  const collectDeletedTestPaths = (
-    previous: TestFileInfo[],
-    current: TestFileInfo[],
-  ): string[] => {
-    const currentPathSet = new Set(current.map((file) => file.testPath));
-    return previous
-      .map((file) => file.testPath)
-      .filter((testPath) => !currentPathSet.has(testPath));
-  };
-
-  const notifyTestRunStart = async (): Promise<void> => {
-    if (!isWatchMode) {
-      return;
-    }
-
-    for (const reporter of context.reporters) {
-      await reporter.onTestRunStart?.();
-    }
-  };
-
-  const coverageConfig = browserProjects.find(
-    (project) => project.normalizedConfig.coverage?.enabled,
-  )?.normalizedConfig.coverage;
-  const coverageProvider = coverageConfig?.enabled
-    ? await createCoverageProvider(coverageConfig, context.rootPath)
-    : null;
-
-  const notifyTestRunEnd = async ({
-    duration,
-    coverage,
-  }: {
-    duration: {
-      totalTime: number;
-      buildTime: number;
-      testTime: number;
-    };
-    coverage?: CoverageMapData;
-  }): Promise<void> => {
-    if (!isWatchMode) {
-      return;
-    }
-
-    for (const reporter of context.reporters) {
-      await reporter.onTestRunEnd?.({
-        results: context.reporterResults.results,
-        coverage,
-        testResults: context.reporterResults.testResults,
-        duration,
-        snapshotSummary: context.snapshotManager.summary,
-        getSourcemap: getBrowserSourcemap,
-      });
-    }
-  };
-
-  const containerDevServerEnv = process.env.RSTEST_CONTAINER_DEV_SERVER;
-  let containerDevServer: string | undefined;
-  let containerDistPath: string | undefined;
-
-  if (!useHeadlessDirect) {
-    if (containerDevServerEnv) {
-      try {
-        containerDevServer = new URL(containerDevServerEnv).toString();
-        logger.debug(
-          `[Browser UI] Using dev server for container: ${containerDevServer}`,
-        );
-      } catch (error) {
-        const originalError = toError(error);
-        originalError.message = `Invalid RSTEST_CONTAINER_DEV_SERVER value: ${originalError.message}`;
-        return failWithError(originalError);
-      }
-    }
-
-    if (!containerDevServer) {
-      try {
-        containerDistPath = resolveContainerDist();
-      } catch (error) {
-        return failWithError(error);
-      }
-    }
-  }
-
-  let projectEntries = await resolveProjectEntries(
-    context,
-    options?.shardedEntries,
-    browserProjects,
-  );
-  let totalTests = projectEntries.reduce(
-    (total, item) => total + item.testFiles.length,
-    0,
-  );
-  const shouldInitializeEmptyBrowserHooks =
-    totalTests === 0 && hasUserRstestConfigPlugins(browserProjects);
-
-  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 = (): void => {
-    const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
-    if (isWatchMode || !allowEmptyRun) {
-      const message = getNoTestFilesMessage({
-        context,
-        code,
-        defaultMessage: `No test files found, exiting with code ${code}.`,
-      });
-      if (code === 0) {
-        logger.log(color.yellow(message));
-      } else {
-        logger.error(color.red(message));
-      }
-
-      if (context.relatedFilters?.length) {
-        logger.log(
-          color.gray('related: '),
-          context.relatedFilters.join(color.gray(', ')),
-        );
-      } else if (context.fileFilters?.length) {
-        logger.log(
-          color.gray('filter: '),
-          context.fileFilters.join(color.gray(', ')),
-        );
-      }
-    }
-
-    // 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 && !allowEmptyRun) {
-      ensureProcessExitCode(code);
-    }
-  };
-
-  if (totalTests === 0 && !shouldInitializeEmptyBrowserHooks) {
-    reportEmptyTestSet();
-    return allowEmptyRun ? createEmptyRunResult() : undefined;
-  }
-
-  if (!filesOnly) {
-    await notifyTestRunStart();
-  }
-
-  const enableCliShortcuts = isWatchMode && isTTY('stdin');
-  const browserTempOutputRoot = context.normalizedConfig.output.distPath.root;
-  const tempDir =
-    isWatchMode && watchContext.runtime
-      ? watchContext.runtime.tempDir
-      : isWatchMode
-        ? join(context.rootPath, browserTempOutputRoot, 'browser', 'watch')
-        : join(
-            context.rootPath,
-            browserTempOutputRoot,
-            'browser',
-            Date.now().toString(),
-          );
-
-  let runtime = isWatchMode ? watchContext.runtime : null;
-
-  // Define rerun callback for watch mode (will be populated later)
-  let triggerRerun: (() => Promise<void>) | undefined;
-  // Headless reruns complete asynchronously in the scheduler's drain loop;
-  // the watch handles await this so callers observe rerun completion.
-  let awaitHeadlessRerunIdle: (() => Promise<void>) | undefined;
-
-  if (!runtime) {
-    try {
-      runtime = await createBrowserRuntime({
-        context,
-        projectEntries,
-        browserProjects,
-        shardedEntries: options?.shardedEntries,
-        freezeShardedEntries: options?.freezeShardedEntries,
-        tempDir,
-        isWatchMode,
-        onTriggerRerun: isWatchMode
-          ? async () => {
-              await triggerRerun?.();
-            }
-          : undefined,
-        containerDistPath,
-        containerDevServer,
-        skipProviderLaunch: filesOnly,
-        appliedModifyRstestConfigEnvironments:
-          options?.appliedModifyRstestConfigEnvironments,
-      });
-    } catch (error) {
-      return failWithError(error, async () => {
-        await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
-      });
-    }
-
-    if (isWatchMode) {
-      watchContext.runtime = runtime;
-      registerWatchCleanup(context.embedded);
-    }
-  }
-
-  const watchState = runtime.watchState;
-
-  // Track initial test files for watch mode (from this controller's freshly
-  // collected entries, before adopting the runtime's entry snapshot below).
-  if (isWatchMode) {
-    watchState.lastTestFiles = collectWatchTestFiles(projectEntries);
-  }
-
-  // Mark files as pending-affected so the next `triggerRerun` reruns them
-  // through the normal plan/schedule/finalize pipeline (used by the watch
-  // handles' explicit reruns; omitted paths = all current files). Returns the
-  // number of seeded files so callers can skip the rerun when a path-scoped
-  // request matches no browser test file (mixed watch 'u' with node-only
-  // snapshot updates).
-  const seedPendingRerun = (testPaths?: string[]): number => {
-    const wanted = testPaths
-      ? new Set(testPaths.map((testPath) => normalize(testPath)))
-      : null;
-    let seeded = 0;
-    for (const file of watchState.lastTestFiles) {
-      if (wanted && !wanted.has(file.testPath)) {
-        continue;
-      }
-      const pending =
-        watchState.pendingAffectedTestFiles.get(file.projectName) ??
-        new Set<string>();
-      pending.add(file.testPath);
-      watchState.pendingAffectedTestFiles.set(file.projectName, pending);
-      seeded += 1;
-    }
-    return seeded;
-  };
-
-  const watchHandles: BrowserWatchHandles | undefined = isWatchMode
-    ? {
-        rerun: async (testPaths) => {
-          const seeded = seedPendingRerun(testPaths);
-          if (testPaths && seeded === 0) {
-            return;
-          }
-          await triggerRerun?.();
-          await awaitHeadlessRerunIdle?.();
-        },
-        close: cleanupWatchRuntime,
-      }
-    : undefined;
-
-  /**
-   * Per-rerun finalize for watch mode: fold the rerun into a synthetic
-   * `ExecutorCycleOutcome` and hand it to core's `finalizeRunCycle`, so
-   * reporter payloads, exit-code never-downgrade semantics, and coverage
-   * reports match the node watch cycle. The trace buffer stays session-owned
-   * (no `traceRun` here); `buildTime` is the drained duration of the
-   * change-triggered compile(s), not a hardcoded zero.
-   */
-  const finalizeWatchRerun = async ({
-    rerunTestPaths,
-    testTime,
-    unhandledErrors,
-  }: {
-    rerunTestPaths: string[];
-    testTime: number;
-    unhandledErrors?: Error[];
-  }): Promise<void> => {
-    const rerunPathSet = new Set(rerunTestPaths);
-    const rerunResults = context.reporterResults.results.filter((result) =>
-      rerunPathSet.has(result.testPath),
-    );
-    // Watch coverage is per-cycle on both transports: only the files this
-    // rerun executed are reported.
-    let rerunCoverage: CoverageMapData | undefined;
-    const coverageMap = buildBrowserCoverageMap(rerunResults, coverageProvider);
-    if (coverageMap && coverageMap.files().length > 0) {
-      rerunCoverage = coverageMap.toJSON();
-    }
-
-    const outcome: ExecutorCycleOutcome = {
-      results: rerunResults,
-      testResults: context.reporterResults.testResults.filter((result) =>
-        rerunPathSet.has(result.testPath),
-      ),
-      errors: unhandledErrors ?? [],
-      testPaths: rerunTestPaths,
-      duration: {
-        buildTime: drainPendingBuildTime(watchState),
-        testTime,
-      },
-      coverage: rerunCoverage ? { map: rerunCoverage } : undefined,
-      resolveSourcemap: resolveBrowserSourcemap,
-    };
-
-    await finalizeRunCycle(context, {
-      outcomes: [outcome],
-      mode: 'on-demand',
-      isWatchMode: true,
-      coverageProvider,
-      reportOnFailure: coverageConfig?.reportOnFailure ?? false,
-    });
-  };
-
-  projectEntries = runtime.projectEntries;
-  totalTests = projectEntries.reduce(
-    (total, item) => total + item.testFiles.length,
-    0,
-  );
-
-  const buildTime = Date.now() - buildStart;
-
-  if (filesOnly) {
-    return {
-      results: [],
-      testResults: [],
-      duration: {
-        totalTime: buildTime,
-        buildTime,
-        testTime: 0,
-      },
-      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) =>
-    entry.testFiles.map((testPath) => ({
-      testPath: normalize(testPath),
-      projectName: entry.project.name,
-    })),
-  );
-
-  // Only include browser mode projects in runtime configs
-  // Normalize projectRoot to posix format for cross-platform compatibility
-  const projectRuntimeConfigs: BrowserProjectRuntime[] = browserProjects.map(
-    (project: ProjectContext) => ({
-      name: project.name,
-      environmentName: project.environmentName,
-      projectRoot: normalize(project.rootPath),
-      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,
-    }),
-  );
-
-  const maxTestTimeoutForRpc = getMaxTestTimeoutForRpc(browserProjects);
-
-  const projectRunnerUrls = Object.fromEntries(
-    [...runtime.projectServers].map(([name, server]) => [
-      name,
-      `http://localhost:${server.port}`,
-    ]),
-  );
-
-  const hostOptions: BrowserHostConfig = {
-    rootPath: normalize(context.rootPath),
-    projects: projectRuntimeConfigs,
-    snapshot: {
-      updateSnapshot:
-        options?.updateSnapshot ??
-        context.snapshotManager.options.updateSnapshot,
-    },
-    // Container origin (fallback). Per-project runner origins below.
-    runnerUrl: `http://localhost:${runtime.containerServer.port}`,
-    projectRunnerUrls,
-    wsPort,
-    debug: isDebug(),
-    rpcTimeout: maxTestTimeoutForRpc,
-  };
-
-  const browserProviderProjects: BrowserProviderProject[] = browserProjects.map(
-    (project) => ({
-      rootPath: normalize(project.rootPath),
-      provider: project.normalizedConfig.browser.provider,
-    }),
-  );
-  const implementationByProvider = new Map<
-    BrowserProvider,
-    BrowserProviderImplementation
-  >();
-  for (const browserProject of browserProviderProjects) {
-    if (!implementationByProvider.has(browserProject.provider)) {
-      implementationByProvider.set(
-        browserProject.provider,
-        getBrowserProviderImplementation(browserProject.provider),
-      );
-    }
-  }
-
-  let activeContainerPage: BrowserProviderPage | null = null;
-  let getHeadlessRunnerPageBySessionId:
-    ((sessionId: string) => BrowserProviderPage | undefined) | undefined;
-
-  const dispatchBrowserRpcRequest = async ({
-    request,
-    target,
-  }: {
-    request: BrowserRpcRequest;
-    target?: BrowserDispatchRequest['target'];
-  }): Promise<unknown> => {
-    const timeoutFallbackMs = maxTestTimeoutForRpc;
-    const provider = resolveProviderForTestPath({
-      testPath: request.testPath,
-      browserProjects: browserProviderProjects,
-    });
-    const implementation = implementationByProvider.get(provider);
-    if (!implementation) {
-      throw new Error(`Browser provider implementation not found: ${provider}`);
-    }
-
-    const runnerPage = target?.sessionId
-      ? getHeadlessRunnerPageBySessionId?.(target.sessionId)
-      : undefined;
-
-    if (target?.sessionId && !runnerPage) {
-      throw new Error(
-        `Runner page session not found for browser dispatch: ${target.sessionId}`,
-      );
-    }
-
-    if (!runnerPage && !activeContainerPage) {
-      throw new Error('Browser container page is not initialized');
-    }
-
-    try {
-      return await implementation.dispatchRpc({
-        containerPage: runnerPage
-          ? undefined
-          : (activeContainerPage ?? undefined),
-        runnerPage,
-        request,
-        timeoutFallbackMs,
-      });
-    } catch (error) {
-      // birpc serializes thrown Errors as `{}` over JSON; throw a string instead.
-      if (error instanceof Error) {
-        throw error.message;
-      }
-      throw String(error);
-    }
-  };
-
-  runtime.dispatchHandlers.set(
-    DISPATCH_NAMESPACE_BROWSER,
-    async (dispatchRequest) => {
-      const request = validateBrowserRpcRequest(dispatchRequest.args);
-      return dispatchBrowserRpcRequest({
-        request,
-        target: dispatchRequest.target,
-      });
-    },
-  );
-
-  runtime.setContainerOptions(hostOptions);
-
-  // Track test results from browser runners
-  const reporterResults: TestFileResult[] = [];
-  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),
-    ]),
-  );
-  // Every per-file wire payload carries its owning project name, so routing
-  // never derives a project from a test path — concurrent projects can run the
-  // same file, and a path-keyed lookup would attribute events to the wrong one.
-  // The client resolves its project from the host's own manifest, so a miss is
-  // a protocol bug; fail loudly rather than route through another project's
-  // config.
-  const sinkForProjectName = (projectName: string): RunnerEventSink => {
-    const sink = runnerSinks.get(projectName);
-    if (!sink) {
-      throw new Error(`No runner event sink for project "${projectName}"`);
-    }
-    return sink;
-  };
-
-  // 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) =>
-      sinkForProjectName(log.project).onConsoleLog(log),
-    writeOriginalLog: () => {},
-  });
-
-  const snapshotRpcMethods = {
-    async resolveSnapshotPath(testPath: string): Promise<string> {
-      return resolveSnapshotPathDefault(
-        testPath,
-        context.normalizedConfig.resolveSnapshotPath,
-      );
-    },
-    async readSnapshotFile(filepath: string): Promise<string | null> {
-      try {
-        return await fs.readFile(filepath, 'utf-8');
-      } catch {
-        return null;
-      }
-    },
-    async saveSnapshotFile(filepath: string, content: string): Promise<void> {
-      const dir = dirname(filepath);
-      await fs.mkdir(dir, { recursive: true });
-      await fs.writeFile(filepath, content, 'utf-8');
-    },
-    async removeSnapshotFile(filepath: string): Promise<void> {
-      try {
-        await fs.unlink(filepath);
-      } catch {
-        // ignore if file doesn't exist
-      }
-    },
-  };
-
-  const handleTestFileStart = async (
-    payload: TestFileStartPayload,
-  ): Promise<void> => {
-    if (phaseTrackers) {
-      const tracker = new PhaseTracker({
-        trace: {
-          testPath: payload.testPath,
-          project: payload.projectName,
-        },
-        pid: nextBrowserFilePid++,
-      });
-      tracker.transition('prepare');
-      phaseTrackers.set(
-        trackerKey(payload.projectName, payload.testPath),
-        tracker,
-      );
-    }
-    // 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,
-      project: payload.projectName,
-      tests: [],
-    });
-  };
-
-  const handleTestFileReady = async (
-    payload: TestFileReadyPayload,
-  ): Promise<void> => {
-    phaseTrackers
-      ?.get(trackerKey(payload.project, payload.testPath))
-      ?.transition('tests');
-    await sinkForProjectName(payload.project).onTestFileReady(payload);
-  };
-
-  const handleTestSuiteStart = async (
-    payload: TestSuiteStartPayload,
-  ): Promise<void> => {
-    phaseTrackers
-      ?.get(trackerKey(payload.project, payload.testPath))
-      ?.recordSuiteStart(payload);
-    await sinkForProjectName(payload.project).onTestSuiteStart(payload);
-  };
-
-  const handleTestSuiteResult = async (
-    payload: TestSuiteResultPayload,
-  ): Promise<void> => {
-    phaseTrackers
-      ?.get(trackerKey(payload.project, payload.testPath))
-      ?.recordSuiteResult(payload);
-    await sinkForProjectName(payload.project).onTestSuiteResult(payload);
-
-    if (context.normalizedConfig.silent === 'passed-only') {
-      silentConsoleController.flushBufferedLogsForTask({
-        taskId: payload.testId,
-        status: payload.status,
-        taskParentNames: payload.parentNames,
-        taskType: 'suite',
-        testPath: payload.testPath,
-      });
-    }
-  };
-
-  const handleTestCaseStart = async (
-    payload: TestCaseStartPayload,
-  ): Promise<void> => {
-    phaseTrackers
-      ?.get(trackerKey(payload.project, payload.testPath))
-      ?.recordCaseStart(payload);
-    // Fire-and-forget on both transports (the sink does not await case-start).
-    sinkForProjectName(payload.project).onTestCaseStart(payload);
-  };
-
-  const handleTestCaseResult = async (payload: TestResult): Promise<void> => {
-    caseResults.push(payload);
-    phaseTrackers
-      ?.get(trackerKey(payload.project, payload.testPath))
-      ?.recordCaseResult(payload);
-    await sinkForProjectName(payload.project).onTestCaseResult(payload);
-
-    if (context.normalizedConfig.silent === 'passed-only') {
-      silentConsoleController.flushBufferedLogsForTask({
-        taskId: payload.testId,
-        status: payload.status,
-        taskParentNames: payload.parentNames,
-        taskType: 'case',
-        testPath: payload.testPath,
-      });
-    }
-  };
-
-  const handleTestFileComplete = async (
-    payload: TestFileResult,
-  ): Promise<void> => {
-    reporterResults.push(payload);
-    context.updateReporterResultState([payload], payload.results);
-
-    if (phaseTrackers) {
-      const key = trackerKey(payload.project, payload.testPath);
-      const tracker = phaseTrackers.get(key);
-      if (tracker) {
-        tracker.end();
-        const events = tracker.getTraceEvents();
-        if (events) onTraceEvents?.(events);
-        phaseTrackers.delete(key);
-      }
-    }
-
-    if (context.normalizedConfig.silent === 'passed-only') {
-      silentConsoleController.flushBufferedLogsForTask({
-        taskId: payload.testId,
-        status: payload.status,
-        taskParentNames: payload.parentNames,
-        taskType: 'file',
-        testPath: payload.testPath,
-      });
-    }
-
-    // Feeds stateManager, fans out onTestFileResult to reporters, and ingests
-    // payload.snapshotResult (the snapshotManager.add moved into the sink).
-    await sinkForProjectName(payload.project).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);
-    }
-  };
-
-  const handleLog = async (payload: LogPayload): Promise<void> => {
-    const log: UserConsoleLog = {
-      content: payload.content,
-      // Same colored level label as the node worker's CustomConsole.
-      name: getPrettyConsoleName(payload.level),
-      taskId: payload.taskId,
-      taskName: payload.taskName,
-      taskParentNames: payload.taskParentNames,
-      taskType: payload.taskType,
-      testPath: payload.testPath,
-      project: payload.projectName,
-      type: payload.type,
-      trace: payload.trace,
-    };
-    silentConsoleController.onConsoleLog(log);
-  };
-
-  const handleFatal = async (payload: FatalPayload): Promise<void> => {
-    const error = new Error(payload.message);
-    error.stack = payload.stack;
-    fatalError = error;
-    // 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);
-    }
-  };
-
-  const runSnapshotRpc = async (
-    request: SnapshotRpcRequest,
-  ): Promise<unknown> => {
-    switch (request.method) {
-      case 'resolveSnapshotPath':
-        return snapshotRpcMethods.resolveSnapshotPath(request.args.testPath);
-      case 'readSnapshotFile':
-        return snapshotRpcMethods.readSnapshotFile(request.args.filepath);
-      case 'saveSnapshotFile':
-        return snapshotRpcMethods.saveSnapshotFile(
-          request.args.filepath,
-          request.args.content,
-        );
-      case 'removeSnapshotFile':
-        return snapshotRpcMethods.removeSnapshotFile(request.args.filepath);
-      default: {
-        // Exhaustiveness guard: a new SnapshotRpcRequest method without a case
-        // here fails to compile rather than silently returning undefined.
-        const _exhaustive: never = request;
-        return _exhaustive;
-      }
-    }
-  };
-
-  const createDispatchRouter = (options?: HostDispatchRouterOptions) => {
-    return createHostDispatchRouter({
-      routerOptions: options,
-      runnerCallbacks: {
-        onTestFileStart: handleTestFileStart,
-        onTestFileReady: handleTestFileReady,
-        onTestSuiteStart: handleTestSuiteStart,
-        onTestSuiteResult: handleTestSuiteResult,
-        onTestCaseStart: handleTestCaseStart,
-        onTestCaseResult: handleTestCaseResult,
-        onTestFileComplete: handleTestFileComplete,
-        onLog: handleLog,
-        onFatal: handleFatal,
-      },
-      runSnapshotRpc,
-      extensionHandlers: runtime.dispatchHandlers,
-      onDuplicateNamespace: (namespace) => {
-        logger.debug(
-          `[Dispatch] Skip registering dispatch namespace "${namespace}" because it is already reserved`,
-        );
-      },
-    });
-  };
-
-  if (useHeadlessDirect) {
-    // Session-based scheduling path: lifecycle + session index + dispatch routing.
-    type ActiveHeadlessRun = RunSession & {
-      contexts: Set<BrowserProviderContext>;
-    };
-
-    const viewportByProject = mapViewportByProject(projectRuntimeConfigs);
-    const runLifecycle = new RunSessionLifecycle<ActiveHeadlessRun>();
-    const sessionRegistry = new RunnerSessionRegistry();
-    getHeadlessRunnerPageBySessionId = (sessionId) => {
-      return sessionRegistry.getById(sessionId)?.page;
-    };
-    let dispatchRequestCounter = 0;
-
-    const nextDispatchRequestId = (namespace: string): string => {
-      return `${namespace}-${++dispatchRequestCounter}`;
-    };
-
-    const closeContextSafely = async (
-      browserContext: BrowserProviderContext,
-    ): Promise<void> => {
-      try {
-        await browserContext.close();
-      } catch {
-        // ignore
-      }
-    };
-
-    const cancelRun = async (
-      run: ActiveHeadlessRun,
-      waitForDone = true,
-    ): Promise<void> => {
-      await runLifecycle.cancel(run, {
-        waitForDone,
-        onCancel: async (session) => {
-          await Promise.all(
-            Array.from(session.contexts).map((browserContext) =>
-              closeContextSafely(browserContext),
-            ),
-          );
-        },
-      });
-    };
-
-    const dispatchRouter = createDispatchRouter({
-      isRunTokenStale: (runToken) => runLifecycle.isTokenStale(runToken),
-      onStale: (request) => {
-        if (request.namespace === DISPATCH_NAMESPACE_RUNNER) {
-          logger.debug(
-            `[Headless] Dropped stale message "${request.method}" for ${request.target?.testFile ?? 'unknown'}`,
-          );
-        }
-      },
-    });
-
-    const dispatchRunnerMessage = async (
-      run: ActiveHeadlessRun,
-      file: TestFileInfo,
-      sessionId: string,
-      message: BrowserClientMessage,
-    ): Promise<void> => {
-      const response = await dispatchRouter.dispatch({
-        requestId: nextDispatchRequestId(DISPATCH_NAMESPACE_RUNNER),
-        runToken: run.token,
-        namespace: DISPATCH_NAMESPACE_RUNNER,
-        method: message.type,
-        args: 'payload' in message ? message.payload : undefined,
-        target: {
-          sessionId,
-          testFile: file.testPath,
-          projectName: file.projectName,
-        },
-      });
-
-      if (response.stale) {
-        return;
-      }
-
-      if (response.error) {
-        throw new Error(response.error);
-      }
-    };
-
-    const runSingleFile = async (
-      run: ActiveHeadlessRun,
-      file: TestFileInfo,
-    ): Promise<void> => {
-      if (run.cancelled || runLifecycle.isTokenStale(run.token)) {
-        return;
-      }
-
-      const viewport = viewportByProject.get(file.projectName);
-      const browserContext = await browser.newContext({
-        providerOptions: browserLaunchOptions.providerOptions,
-        viewport: viewport ?? null,
-      });
-      run.contexts.add(browserContext);
-
-      let page: BrowserProviderPage | null = null;
-      let sessionId: string | null = null;
-      let settled = false;
-      let resolveDone: (() => void) | null = null;
-
-      const markDone = (): void => {
-        if (!settled) {
-          settled = true;
-          resolveDone?.();
-        }
-      };
-
-      const donePromise = new Promise<void>((resolve) => {
-        resolveDone = resolve;
-      });
-
-      // Event-driven death detection (vitest-style): a renderer crash or an
-      // unexpected page close produces no further messages, so fail the file at
-      // once. Per-test/hook timeouts are enforced inside the runner, so the host
-      // deliberately keeps no execution-duration watchdog. Our own teardown
-      // close is ignored because `settled`/`run.cancelled` are set by then.
-      const crashDeferred = createDeferredPromise<string>();
-      const onPageDead = (reason: string): void => {
-        if (
-          settled ||
-          run.cancelled ||
-          !runLifecycle.isTokenActive(run.token)
-        ) {
-          return;
-        }
-        settled = true;
-        crashDeferred.resolve(reason);
-      };
-
-      try {
-        page = await browserContext.newPage();
-        page.on('crash', () =>
-          onPageDead(`Browser page crashed while running ${file.testPath}.`),
-        );
-        page.on('close', () =>
-          onPageDead(
-            `Browser page closed unexpectedly while running ${file.testPath}.`,
-          ),
-        );
-
-        const session = sessionRegistry.register({
-          testFile: file.testPath,
-          projectName: file.projectName,
-          runToken: run.token,
-          mode: 'headless-page',
-          context: browserContext,
-          page,
-        });
-        sessionId = session.id;
-
-        await attachHeadlessRunnerTransport(page, {
-          onDispatchMessage: async (message) => {
-            try {
-              await dispatchRunnerMessage(run, file, session.id, message);
-              if (
-                message.type === 'file-complete' ||
-                message.type === 'complete'
-              ) {
-                markDone();
-              } else if (message.type === 'fatal') {
-                markDone();
-                await cancelRun(run, false);
-              }
-            } catch (error) {
-              const formatted = toError(error);
-              await handleFatal({
-                message: formatted.message,
-                stack: formatted.stack,
-              });
-              markDone();
-              await cancelRun(run, false);
-            }
-          },
-          onDispatchRpc: async (request) => {
-            return dispatchRouter.dispatch({
-              ...request,
-              runToken: run.token,
-              target: {
-                sessionId: session.id,
-                testFile: file.testPath,
-                projectName: file.projectName,
-                ...request.target,
-              },
-            });
-          },
-        });
-
-        const inlineOptions: BrowserHostConfig = {
-          ...hostOptions,
-          // Read live per page load, not from the construction-time
-          // `hostOptions` value: the 'u' shortcut flips
-          // `snapshotManager.options` between reruns.
-          snapshot: {
-            updateSnapshot: context.snapshotManager.options.updateSnapshot,
-          },
-          testFile: file.testPath,
-          runId: `${run.token}:${session.id}`,
-        };
-        const serializedOptions = serializeForInlineScript(inlineOptions);
-        await page.addInitScript(
-          `window.__RSTEST_BROWSER_OPTIONS__ = ${serializedOptions};`,
-        );
-
-        const projectServer = runtime.projectServers.get(file.projectName);
-        if (!projectServer) {
-          throw new Error(
-            `No browser dev server for project "${file.projectName}" (test file: ${file.testPath}).`,
-          );
-        }
-        await page.goto(`http://localhost:${projectServer.port}/runner.html`, {
-          waitUntil: 'load',
-        });
-
-        const state = await Promise.race([
-          donePromise.then(() => ({ type: 'done' as const })),
-          crashDeferred.promise.then((reason) => ({
-            type: 'crash' as const,
-            reason,
-          })),
-          run.cancelSignal.then(() => ({ type: 'cancelled' as const })),
-        ]);
-
-        if (state.type === 'cancelled') {
-          return;
-        }
-
-        if (
-          state.type === 'crash' &&
-          runLifecycle.isTokenActive(run.token) &&
-          !run.cancelled
-        ) {
-          await handleFatal({ message: state.reason });
-          await cancelRun(run, false);
-        }
-      } catch (error) {
-        if (runLifecycle.isTokenActive(run.token) && !run.cancelled) {
-          const formatted = toError(error);
-          await handleFatal({
-            message: formatted.message,
-            stack: formatted.stack,
-          });
-          await cancelRun(run, false);
-        }
-      } finally {
-        if (page) {
-          try {
-            await page.close();
-          } catch {
-            // ignore
-          }
-        }
-        if (sessionId) {
-          sessionRegistry.deleteById(sessionId);
-        }
-        run.contexts.delete(browserContext);
-        await closeContextSafely(browserContext);
-      }
-    };
-
-    // 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;
-      }
-
-      const previous = runLifecycle.activeSession;
-      if (previous) {
-        await cancelRun(previous);
-      }
-
-      const run = runLifecycle.createSession((token) => ({
-        ...createRunSession(token),
-        contexts: new Set<BrowserProviderContext>(),
-      }));
-
-      const queue = [...files];
-      const concurrency = getHeadlessConcurrency(context, queue.length);
-      const bail = context.normalizedConfig.bail;
-
-      const worker = async (): Promise<void> => {
-        while (
-          queue.length > 0 &&
-          !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;
-          }
-          await runSingleFile(run, next);
-        }
-      };
-
-      run.done = Promise.all(
-        Array.from(
-          { length: Math.min(queue.length, Math.max(concurrency, 1)) },
-          () => worker(),
-        ),
-      ).then(() => {});
-
-      await run.done;
-      runLifecycle.clearIfActive(run);
-    };
-
-    const latestRerunScheduler = createHeadlessLatestRerunScheduler<
-      TestFileInfo,
-      ActiveHeadlessRun
-    >({
-      getActiveRun: () => runLifecycle.activeSession,
-      isRunCancelled: (run) => run.cancelled,
-      invalidateActiveRun: () => {
-        runLifecycle.invalidateActiveToken();
-      },
-      interruptActiveRun: async (run) => {
-        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();
-        const fatalErrorBeforeRun = fatalError;
-        let rerunError: Error | undefined;
-
-        try {
-          await runFilesWithPool(files);
-        } catch (error) {
-          rerunError = toError(error);
-          throw error;
-        } finally {
-          const testTime = Math.max(0, Date.now() - rerunStartTime);
-          const rerunFatalError =
-            fatalError && fatalError !== fatalErrorBeforeRun
-              ? fatalError
-              : undefined;
-          await finalizeWatchRerun({
-            rerunTestPaths: files.map((file) => file.testPath),
-            testTime,
-            unhandledErrors: rerunError
-              ? [rerunError]
-              : rerunFatalError
-                ? [rerunFatalError]
-                : undefined,
-          });
-          logWatchReadyMessage(context, enableCliShortcuts);
-        }
-      },
-      onError: async (error) => {
-        const formatted = toError(error);
-        await handleFatal({
-          message: formatted.message,
-          stack: formatted.stack,
-        });
-      },
-      onInterrupt: (run) => {
-        logger.debug(
-          `[Headless] Interrupting active run token ${run.token} before scheduling latest rerun`,
-        );
-      },
-    });
-
-    awaitHeadlessRerunIdle = () => latestRerunScheduler.whenIdle();
-
-    const testStart = Date.now();
-    await runFilesWithPool(allTestFiles);
-    const testTime = Date.now() - testStart;
-
-    if (isWatchMode) {
-      triggerRerun = async () => {
-        const newProjectEntries = await collectProjectEntries(context);
-        const rerunPlan = planWatchRerun({
-          projectEntries: newProjectEntries,
-          previousTestFiles: watchState.lastTestFiles,
-          affectedTestFiles: drainPendingAffectedTestFiles(watchState),
-        });
-
-        if (rerunPlan.filesChanged) {
-          const deletedTestPaths = collectDeletedTestPaths(
-            watchState.lastTestFiles,
-            rerunPlan.currentTestFiles,
-          );
-          if (deletedTestPaths.length > 0) {
-            context.updateReporterResultState([], [], deletedTestPaths);
-          }
-          watchState.lastTestFiles = rerunPlan.currentTestFiles;
-          if (rerunPlan.currentTestFiles.length === 0) {
-            await latestRerunScheduler.enqueueLatest([]);
-            logger.log(
-              color.cyan('No browser test files remain after update.\n'),
-            );
-            logWatchReadyMessage(context, enableCliShortcuts);
-            return;
-          }
-
-          logger.log(
-            color.cyan(
-              `Test file set changed, re-running ${rerunPlan.currentTestFiles.length} file(s)...\n`,
-            ),
-          );
-          await latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
-          return;
-        }
-
-        if (rerunPlan.affectedTestFiles.length === 0) {
-          logger.log(
-            color.cyan(
-              'No affected browser test files detected, skipping re-run.\n',
-            ),
-          );
-          logWatchReadyMessage(context, enableCliShortcuts);
-          return;
-        }
-
-        logger.log(
-          color.cyan(
-            `Re-running ${rerunPlan.affectedTestFiles.length} affected test file(s)...\n`,
-          ),
-        );
-        await latestRerunScheduler.enqueueLatest(rerunPlan.affectedTestFiles);
-      };
-    }
-
-    const closeHeadlessRuntime = !isWatchMode
-      ? async () => {
-          sessionRegistry.clear();
-          await destroyBrowserRuntime(runtime);
-        }
-      : undefined;
-
-    if (fatalError) {
-      return failWithError(fatalError, closeHeadlessRuntime);
-    }
-
-    const duration = {
-      totalTime: buildTime + testTime,
-      buildTime,
-      testTime,
-    };
-
-    context.updateReporterResultState(reporterResults, caseResults);
-
-    const isFailure = reporterResults.some(
-      (result: TestFileResult) => result.status === 'fail',
-    );
-    // 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);
-    }
-
-    // Fold and strip the initial cycle's coverage (the same per-cycle fold
-    // reruns get in `finalizeWatchRerun`); the map rides on the result so the
-    // browser-only watch path can report it without re-merging. Non-watch runs
-    // keep `result.coverage` intact for the executor's outcome fold.
-    const cycleCoverageMap =
-      isWatchMode && coverageProvider
-        ? buildBrowserCoverageMap(reporterResults, coverageProvider)
-        : undefined;
-
-    const result = {
-      results: reporterResults,
-      testResults: caseResults,
-      duration,
-      hasFailure: isFailure,
-      getSourcemap: getBrowserSourcemap,
-      resolveSourcemap: resolveBrowserSourcemap,
-      // `closeHeadlessRuntime` is already `undefined` in watch mode, so the
-      // non-watch caller (core) receives the deferred close and watch does not.
-      close: closeHeadlessRuntime,
-      coverage: cycleCoverageMap,
-      watch: watchHandles,
-    };
-
-    if (isWatchMode) {
-      try {
-        await notifyTestRunEnd({
-          duration,
-          coverage: cycleCoverageMap?.files().length
-            ? cycleCoverageMap.toJSON()
-            : undefined,
-        });
-      } finally {
-        await closeHeadlessRuntime?.();
-      }
-    }
-
-    if (isWatchMode && triggerRerun) {
-      watchState.hooksEnabled = true;
-      logWatchReadyMessage(context, enableCliShortcuts);
-    }
-
-    return result;
-  }
-
-  let currentTestFiles = allTestFiles;
-  // Coincidentally equal to the runner-side CONFIG_WAIT_TIMEOUT_MS and
-  // DEFAULT_RPC_TIMEOUT_MS (client/entry.ts, client/dispatchTransport.ts) but
-  // semantically distinct and in a different runtime, so deliberately NOT shared
-  // with them. Invariant worth preserving: a runner must be able to receive its
-  // config (config-wait) before the host declares its frames un-ready, i.e.
-  // CONFIG_WAIT_TIMEOUT_MS <= RUNNER_FRAMES_READY_TIMEOUT_MS.
-  const RUNNER_FRAMES_READY_TIMEOUT_MS = 30_000;
-  let currentRunnerFramesSignature: string | null = null;
-  const runnerFramesWaiters = new Map<string, Set<() => void>>();
-
-  const createTestFilesSignature = (testFiles: readonly string[]): string => {
-    return JSON.stringify(testFiles.map((testFile) => normalize(testFile)));
-  };
-
-  const markRunnerFramesReady = (testFiles: string[]): void => {
-    const signature = createTestFilesSignature(testFiles);
-    currentRunnerFramesSignature = signature;
-    const waiters = runnerFramesWaiters.get(signature);
-    if (!waiters) {
-      return;
-    }
-    runnerFramesWaiters.delete(signature);
-    for (const waiter of waiters) {
-      waiter();
-    }
-  };
-
-  const waitForRunnerFramesReady = async (
-    testFiles: readonly string[],
-  ): Promise<void> => {
-    const signature = createTestFilesSignature(testFiles);
-    if (currentRunnerFramesSignature === signature) {
-      return;
-    }
-
-    await new Promise<void>((resolve, reject) => {
-      const waiters =
-        runnerFramesWaiters.get(signature) ?? new Set<() => void>();
-
-      const cleanup = () => {
-        const currentWaiters = runnerFramesWaiters.get(signature);
-        if (!currentWaiters) {
-          return;
-        }
-        currentWaiters.delete(onReady);
-        if (currentWaiters.size === 0) {
-          runnerFramesWaiters.delete(signature);
-        }
-      };
-
-      const onReady = () => {
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
-        cleanup();
-        resolve();
-      };
-
-      const timeoutId = setTimeout(() => {
-        cleanup();
-        reject(
-          new Error(
-            `Timed out waiting for headed runner frames to be ready for ${testFiles.length} file(s).`,
-          ),
-        );
-      }, RUNNER_FRAMES_READY_TIMEOUT_MS);
-
-      waiters.add(onReady);
-      runnerFramesWaiters.set(signature, waiters);
-
-      if (currentRunnerFramesSignature === signature) {
-        onReady();
-      }
-    });
-  };
-
-  const getTestFileInfo = (testFile: string): TestFileInfo => {
-    const normalizedTestFile = normalize(testFile);
-    const fileInfo = currentTestFiles.find(
-      (file) => file.testPath === normalizedTestFile,
-    );
-    if (!fileInfo) {
-      throw new Error(`Unknown browser test file: ${JSON.stringify(testFile)}`);
-    }
-    return fileInfo;
-  };
-
-  // Open a container page for user to view (reuse in watch mode)
-  let containerContext: BrowserProviderContext;
-  let containerPage: BrowserProviderPage;
-  let isNewPage = false;
-
-  if (isWatchMode && runtime.containerPage && runtime.containerContext) {
-    containerContext = runtime.containerContext;
-    containerPage = runtime.containerPage;
-    logger.log(color.gray('\n[Watch] Reusing existing container page\n'));
-  } else {
-    isNewPage = true;
-    containerContext = await browser.newContext({
-      providerOptions: browserLaunchOptions.providerOptions,
-      viewport: null,
-    });
-    containerPage = await containerContext.newPage();
-
-    // Prevent popup windows from being created
-    containerPage.on('popup', async (popup: BrowserProviderPage) => {
-      await popup.close().catch(() => {});
-    });
-
-    containerContext.on('page', async (page: BrowserProviderPage) => {
-      if (page !== containerPage) {
-        await page.close().catch(() => {});
-      }
-    });
-
-    if (isWatchMode) {
-      runtime.containerPage = containerPage;
-      runtime.containerContext = containerContext;
-    }
-
-    // Forward browser console to terminal
-    containerPage.on('console', (msg) => {
-      const text = msg.text();
-      if (text.startsWith('[Container]') || text.startsWith('[Runner]')) {
-        logger.log(color.gray(`[Browser Console] ${text}`));
-      }
-    });
-  }
-
-  activeContainerPage = containerPage;
-
-  const dispatchRouter = createDispatchRouter();
-  const headedReloadQueue = createHeadedSerialTaskQueue();
-  const pendingHeadedReloads = new Map<
-    string,
-    {
-      runId: string;
-      deferred: DeferredPromise<void>;
-    }
-  >();
-  let enqueueHeadedReload = async (
-    _file: TestFileInfo,
-    _testNamePattern?: string,
-  ): Promise<void> => {
-    throw new Error('Headed reload queue is not initialized');
-  };
-
-  const rejectPendingHeadedReload = (
-    testPath: string,
-    error: Error,
-    runId?: string,
-  ): void => {
-    const pending = pendingHeadedReloads.get(testPath);
-    if (!pending) {
-      return;
-    }
-    if (runId && pending.runId !== runId) {
-      return;
-    }
-    pendingHeadedReloads.delete(testPath);
-    pending.deferred.reject(error);
-  };
-
-  const rejectAllPendingHeadedReloads = (error: Error): void => {
-    for (const [testPath, pending] of pendingHeadedReloads) {
-      pendingHeadedReloads.delete(testPath);
-      pending.deferred.reject(error);
-    }
-  };
-
-  const registerPendingHeadedReload = (
-    testPath: string,
-    runId: string,
-  ): Promise<void> => {
-    const previousPending = pendingHeadedReloads.get(testPath);
-    if (previousPending) {
-      previousPending.deferred.reject(
-        new Error(
-          `Reload for "${testPath}" was superseded by a newer request.`,
-        ),
-      );
-      pendingHeadedReloads.delete(testPath);
-    }
-
-    const deferred = createDeferredPromise<void>();
-    pendingHeadedReloads.set(testPath, {
-      runId,
-      deferred,
-    });
-
-    return deferred.promise;
-  };
-
-  const resolvePendingHeadedReload = (
-    testPath: string,
-    runId?: string,
-  ): void => {
-    const pending = pendingHeadedReloads.get(testPath);
-    if (!pending) {
-      return;
-    }
-    if (runId && pending.runId !== runId) {
-      logger.debug(
-        `[Browser UI] Ignoring stale file-complete for ${testPath}. current=${pending.runId}, incoming=${runId}`,
-      );
-      return;
-    }
-    pendingHeadedReloads.delete(testPath);
-    pending.deferred.resolve();
-  };
-
-  // No execution-duration watchdog: per-test/hook timeouts are enforced inside
-  // the runner, and a dead container is caught event-driven by the WebSocket
-  // `close` handler, which rejects every pending reload via `onDisconnect`.
-  const reloadTestFileAndWait = async (
-    file: TestFileInfo,
-    testNamePattern?: string,
-  ): Promise<void> => {
-    let reloadAck: ReloadTestFileAck | undefined;
-
-    try {
-      reloadAck = await rpcManager.reloadTestFile(
-        file.testPath,
-        testNamePattern,
-      );
-      await registerPendingHeadedReload(file.testPath, reloadAck.runId);
-    } catch (error) {
-      if (reloadAck?.runId) {
-        rejectPendingHeadedReload(
-          file.testPath,
-          toError(error),
-          reloadAck.runId,
-        );
-      }
-      throw error;
-    }
-  };
-
-  // Create RPC methods that can access test state variables
-  const createRpcMethods = (): HostRpcMethods => ({
-    async rerunTest(testFile: string, testNamePattern?: string) {
-      const projectName = context.normalizedConfig.name || 'project';
-      const relativePath = relative(context.rootPath, testFile);
-      const displayPath = `<${projectName}>/${relativePath}`;
-      logger.log(
-        color.cyan(
-          `\nRe-running test: ${displayPath}${testNamePattern ? ` (pattern: ${testNamePattern})` : ''}\n`,
-        ),
-      );
-      await enqueueHeadedReload(getTestFileInfo(testFile), testNamePattern);
-    },
-    async getTestFiles() {
-      return currentTestFiles;
-    },
-    async onRunnerFramesReady(testFiles: string[]) {
-      markRunnerFramesReady(testFiles);
-    },
-    async onTestFileStart(payload: TestFileStartPayload) {
-      await handleTestFileStart(payload);
-    },
-    async onTestCaseResult(payload: TestResult) {
-      await handleTestCaseResult(payload);
-    },
-    async onTestFileComplete(payload: HeadedTestFileCompletePayload) {
-      try {
-        await handleTestFileComplete(payload);
-        resolvePendingHeadedReload(payload.testPath, payload.runId);
-      } catch (error) {
-        rejectPendingHeadedReload(
-          payload.testPath,
-          toError(error),
-          payload.runId,
-        );
-        throw error;
-      }
-    },
-    async onLog(payload: LogPayload) {
-      await handleLog(payload);
-    },
-    async onFatal(payload: FatalPayload) {
-      const error = new Error(payload.message);
-      error.stack = payload.stack;
-      rejectAllPendingHeadedReloads(error);
-      await handleFatal(payload);
-    },
-    async dispatch(request: BrowserDispatchRequest) {
-      // Headed/container path now shares the same dispatch contract as headless.
-      return dispatchRouter.dispatch(request);
-    },
-  });
-
-  // Setup RPC manager
-  let rpcManager: ContainerRpcManager;
-
-  if (isWatchMode && runtime.rpcManager) {
-    rpcManager = runtime.rpcManager;
-    // Update methods with new test state (caseResults, completedTests, etc.)
-    rpcManager.updateMethods(createRpcMethods(), rejectAllPendingHeadedReloads);
-    // Reattach if we have an existing WebSocket
-    const existingWs = rpcManager.currentWebSocket;
-    if (existingWs) {
-      rpcManager.reattach(existingWs);
-    }
-  } else {
-    rpcManager = new ContainerRpcManager(
-      wss,
-      createRpcMethods(),
-      rejectAllPendingHeadedReloads,
-    );
-
-    if (isWatchMode) {
-      runtime.rpcManager = rpcManager;
-    }
-  }
-
-  // Only navigate on first creation
-  if (isNewPage) {
-    const pagePath = '/';
-    const containerPort = runtime.containerServer.port;
-    await containerPage.goto(`http://localhost:${containerPort}${pagePath}`, {
-      waitUntil: 'load',
-    });
-
-    logger.log(
-      color.cyan(
-        `\nBrowser mode opened at http://localhost:${containerPort}${pagePath}\n`,
-      ),
-    );
-  }
-
-  enqueueHeadedReload = async (
-    file: TestFileInfo,
-    testNamePattern?: string,
-  ): Promise<void> => {
-    return headedReloadQueue.enqueue(async () => {
-      if (fatalError) {
-        return;
-      }
-      await reloadTestFileAndWait(file, testNamePattern);
-    });
-  };
-
-  let testTime = 0;
-  if (currentTestFiles.length > 0) {
-    const testStart = Date.now();
-    try {
-      await waitForRunnerFramesReady(
-        currentTestFiles.map((file) => file.testPath),
-      );
-
-      for (const file of currentTestFiles) {
-        await enqueueHeadedReload(file);
-        if (fatalError) {
-          break;
-        }
-      }
-    } catch (error) {
-      fatalError = fatalError ?? toError(error);
-      // 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;
-  }
-
-  // Define rerun logic for watch mode
-  if (isWatchMode) {
-    triggerRerun = async () => {
-      // Re-deliver the host config so runner iframes reloaded by this rerun
-      // observe live per-rerun values ('u' flips updateSnapshot between
-      // reruns); `setContainerOptions` keeps full container reloads in sync.
-      const refreshedHostOptions: BrowserHostConfig = {
-        ...hostOptions,
-        snapshot: {
-          updateSnapshot: context.snapshotManager.options.updateSnapshot,
-        },
-      };
-      runtime.setContainerOptions(refreshedHostOptions);
-      // Independent: config push to the container vs. local entry collection.
-      const [, newProjectEntries] = await Promise.all([
-        rpcManager.updateHostConfig(refreshedHostOptions),
-        collectProjectEntries(context),
-      ]);
-      const rerunPlan = planWatchRerun({
-        projectEntries: newProjectEntries,
-        previousTestFiles: watchState.lastTestFiles,
-        affectedTestFiles: drainPendingAffectedTestFiles(watchState),
-      });
-
-      if (rerunPlan.filesChanged) {
-        const deletedTestPaths = collectDeletedTestPaths(
-          watchState.lastTestFiles,
-          rerunPlan.currentTestFiles,
-        );
-        if (deletedTestPaths.length > 0) {
-          context.updateReporterResultState([], [], deletedTestPaths);
-        }
-        watchState.lastTestFiles = rerunPlan.currentTestFiles;
-        currentTestFiles = rerunPlan.currentTestFiles;
-        await rpcManager.notifyTestFileUpdate(currentTestFiles);
-        if (currentTestFiles.length === 0) {
-          logger.log(
-            color.cyan('No browser test files remain after update.\n'),
-          );
-          logWatchReadyMessage(context, enableCliShortcuts);
-          return;
-        }
-        await waitForRunnerFramesReady(
-          currentTestFiles.map((file) => file.testPath),
-        );
-      }
-
-      if (rerunPlan.normalizedAffectedTestFiles.length > 0) {
-        logger.log(
-          color.cyan(
-            `Re-running ${rerunPlan.normalizedAffectedTestFiles.length} affected test file(s)...\n`,
-          ),
-        );
-        // 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();
-        const fatalErrorBeforeRun = fatalError;
-        let rerunError: Error | undefined;
-
-        try {
-          for (const testFile of rerunPlan.normalizedAffectedTestFiles) {
-            await enqueueHeadedReload(getTestFileInfo(testFile));
-          }
-        } catch (error) {
-          rerunError = toError(error);
-          throw error;
-        } finally {
-          const testTime = Math.max(0, Date.now() - rerunStartTime);
-          const rerunFatalError =
-            fatalError && fatalError !== fatalErrorBeforeRun
-              ? fatalError
-              : undefined;
-          await finalizeWatchRerun({
-            rerunTestPaths: rerunPlan.normalizedAffectedTestFiles,
-            testTime,
-            unhandledErrors: rerunError
-              ? [rerunError]
-              : rerunFatalError
-                ? [rerunFatalError]
-                : undefined,
-          });
-          logWatchReadyMessage(context, enableCliShortcuts);
-        }
-      } else if (!rerunPlan.filesChanged) {
-        logger.log(color.cyan('Tests will be re-executed automatically\n'));
-        logWatchReadyMessage(context, enableCliShortcuts);
-      } else {
-        logWatchReadyMessage(context, enableCliShortcuts);
-      }
-    };
-  }
-
-  const closeContainerRuntime = !isWatchMode
-    ? async () => {
-        try {
-          await containerPage.close();
-        } catch {
-          // ignore
-        }
-        try {
-          await containerContext.close();
-        } catch {
-          // ignore
-        }
-        await destroyBrowserRuntime(runtime);
-      }
-    : undefined;
-
-  if (fatalError) {
-    return failWithError(fatalError, closeContainerRuntime);
-  }
-
-  const duration = {
-    totalTime: buildTime + testTime,
-    buildTime,
-    testTime,
-  };
-
-  context.updateReporterResultState(reporterResults, caseResults);
-
-  const isFailure = reporterResults.some(
-    (result: TestFileResult) => result.status === 'fail',
-  );
-  // 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);
-  }
-
-  // Same per-cycle fold-and-strip as the headless path above.
-  const cycleCoverageMap =
-    isWatchMode && coverageProvider
-      ? buildBrowserCoverageMap(reporterResults, coverageProvider)
-      : undefined;
-
-  const result = {
-    results: reporterResults,
-    testResults: caseResults,
-    duration,
-    hasFailure: isFailure,
-    getSourcemap: getBrowserSourcemap,
-    resolveSourcemap: resolveBrowserSourcemap,
-    // `closeContainerRuntime` is already `undefined` in watch mode, so the
-    // non-watch caller (core) receives the deferred close and watch does not.
-    close: closeContainerRuntime,
-    coverage: cycleCoverageMap,
-    watch: watchHandles,
-  };
-
-  if (isWatchMode) {
-    try {
-      await notifyTestRunEnd({
-        duration,
-        coverage: cycleCoverageMap?.files().length
-          ? cycleCoverageMap.toJSON()
-          : undefined,
-      });
-    } finally {
-      await closeContainerRuntime?.();
-    }
-  }
-
-  // Enable watch hooks AFTER initial test run to avoid duplicate runs
-  if (isWatchMode && triggerRerun) {
-    watchState.hooksEnabled = true;
-    logWatchReadyMessage(context, enableCliShortcuts);
-  }
-
-  return result;
-};
-
-// ============================================================================
-// List Browser Tests
-// ============================================================================
-
-/**
- * Result from collecting browser tests.
- * This is the return type for listBrowserTests, designed for future extraction
- * to a separate browser package.
- */
-export type ListBrowserTestsResult = {
-  list: ListCommandResult[];
-  close: () => Promise<void>;
-};
-
-/**
- * Collect test metadata from browser mode projects without running them.
- * This function creates a headless browser runtime, loads test files,
- * and collects their test structure (describe/test declarations).
- */
-export const listBrowserTests = async (
-  context: RstestContext,
-  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 && !hasUserRstestConfigPlugins(browserProjects)) {
-    return {
-      list: [],
-      close: async () => {},
-    };
-  }
-
-  const tempDir = join(
-    context.rootPath,
-    context.normalizedConfig.output.distPath.root,
-    'browser',
-    `list-${Date.now()}`,
-  );
-
-  // 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 = [
-      ...new Set(
-        browserProjects.map((p) => p.normalizedConfig.browser.provider),
-      ),
-    ];
-    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;
-
-  // Get browser projects for runtime config
-  // Normalize projectRoot to posix format for cross-platform compatibility
-  const projectRuntimeConfigs: BrowserProjectRuntime[] = browserProjects.map(
-    (project: ProjectContext) => ({
-      name: project.name,
-      environmentName: project.environmentName,
-      projectRoot: normalize(project.rootPath),
-      runtimeConfig: serializableConfig(
-        projectRuntimeConfig(project, { envMode: 'static' }),
-      ),
-      viewport: project.normalizedConfig.browser.viewport,
-    }),
-  );
-
-  const maxTestTimeoutForRpc = getMaxTestTimeoutForRpc(browserProjects);
-
-  const hostOptions: BrowserHostConfig = {
-    rootPath: normalize(context.rootPath),
-    projects: projectRuntimeConfigs,
-    snapshot: {
-      updateSnapshot: context.snapshotManager.options.updateSnapshot,
-    },
-    mode: 'collect', // Use collect mode
-    debug: isDebug(),
-    rpcTimeout: maxTestTimeoutForRpc,
-  };
-
-  runtime.setContainerOptions(hostOptions);
-
-  // Collect results across every project's isolated dev server. Each server
-  // serves only its own project's manifest, so collection navigates one page
-  // per project; each page returns its own results, aggregated afterwards.
-  const browserContext = await browser.newContext({
-    providerOptions: browserLaunchOptions.providerOptions,
-    viewport: null,
-  });
-
-  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 }> => {
-    const results: ListCommandResult[] = [];
-    let error: Error | null = null;
-    let collectCompleted = false;
-    let resolveCollect: (() => void) | undefined;
-    const collectPromise = new Promise<void>((resolve) => {
-      resolveCollect = resolve;
-    });
-
-    const page = await browserContext.newPage();
-
-    // Expose dispatch function for browser client to send messages
-    await page.exposeFunction(
-      DISPATCH_MESSAGE_TYPE,
-      (message: { type: string; payload?: unknown }) => {
-        switch (message.type) {
-          case 'collect-result': {
-            const payload = message.payload as {
-              testPath: string;
-              project: string;
-              tests: Test[];
-            };
-            results.push({
-              testPath: payload.testPath,
-              project: payload.project,
-              tests: payload.tests,
-            });
-            break;
-          }
-          case 'collect-complete':
-            collectCompleted = true;
-            resolveCollect?.();
-            break;
-          case 'fatal': {
-            const payload = message.payload as {
-              message: string;
-              stack?: string;
-            };
-            error = new Error(payload.message);
-            error.stack = payload.stack;
-            resolveCollect?.();
-            break;
-          }
-          case 'ready':
-          case 'log':
-            // Ignore these messages during collection
-            break;
-          default:
-            // Log unexpected messages for debugging
-            logger.debug(`[List] Unexpected message: ${message.type}`);
-        }
-      },
-    );
-
-    // Inject host options before navigation so the runner can access them
-    await page.addInitScript(
-      `window.__RSTEST_BROWSER_OPTIONS__ = ${serializedOptions};`,
-    );
-
-    // Navigate to this project's runner page
-    await page.goto(`http://localhost:${server.port}/runner.html`, {
-      waitUntil: 'load',
-    });
-
-    // 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 ${collectTimeoutMs}ms`,
-            ),
-          );
-        }
-        resolve();
-      }, collectTimeoutMs);
-    });
-
-    await Promise.race([collectPromise, timeoutPromise]);
-
-    // Clear timeout to prevent Node.js from waiting for it
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-
-    await page.close().catch(() => {});
-    return { results, error };
-  };
-
-  // Collect every project concurrently — each navigates its own page against
-  // its own dev server and returns its own results.
-  const collected = await Promise.all(
-    [...runtime.projectServers.values()].map((server) =>
-      collectFromServer(server),
-    ),
-  );
-  const collectResults = collected.flatMap((entry) => entry.results);
-  const fatalError = collected.find((entry) => entry.error)?.error ?? null;
-
-  // Cleanup
-  const cleanup = async () => {
-    try {
-      await browserContext.close();
-    } catch {
-      // ignore
-    }
-    await destroyBrowserRuntime(runtime);
-  };
-
-  if (fatalError) {
-    await cleanup();
-    // Return error in the result format instead of throwing
-    const errorResult: ListCommandResult = {
-      testPath: '',
-      project: '',
-      tests: [],
-      errors: [
-        {
-          name: 'BrowserCollectError',
-          message: fatalError.message,
-          stack: fatalError.stack,
-        } as FormattedError,
-      ],
-    };
-    return {
-      list: [errorResult],
-      close: async () => {},
-    };
-  }
-
-  return {
-    list: collectResults,
-    close: cleanup,
-  };
-};