@rstest/browser 0.11.3 → 0.11.5

package/src/hostController.ts

@@ -6,10 +6,17 @@ 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,
@@ -25,9 +32,11 @@ import {
   importMetaRstestDefine,
   initModifyRstestConfigHooks,
   isDebug,
+  isTTY,
   type ListCommandResult,
   loadCoverageProvider,
   logger,
+  logWatchReadyMessage,
   pluginMockRuntime,
   prepareWatchRerunState,
   projectRuntimeConfig,
@@ -46,6 +55,7 @@ import {
   type TestFileResult,
   type TestResult,
   type UserConsoleLog,
+  type WatchInvalidationState,
 } from '@rstest/core/internal/browser';
 import { type BirpcReturn, createBirpc } from 'birpc';
 import openEditor from 'open-editor';
@@ -101,11 +111,6 @@ import {
   type SourceMapPayload,
 } from './sourceMap/sourceMapLoader';
 import { resolveBrowserViewportPreset } from './viewportPresets';
-import {
-  isBrowserWatchCliShortcutsEnabled,
-  logBrowserWatchReadyMessage,
-  setupBrowserWatchCliShortcuts,
-} from './watchCliShortcuts';
 import { collectWatchTestFiles, planWatchRerun } from './watchRerunPlanner';
 
 const { createRsbuild, rspack } = rsbuild;
@@ -255,6 +260,12 @@ type ContainerRpcMethods = {
     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>;
@@ -394,6 +405,11 @@ class ContainerRpcManager {
     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,
@@ -428,6 +444,56 @@ type BrowserProjectServer = {
   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>;
@@ -446,32 +512,27 @@ type BrowserRuntime = {
   wss: WebSocketServer;
   rpcManager?: ContainerRpcManager;
   projectEntries: BrowserProjectEntries[];
+  watchState: BrowserWatchState;
 };
 
 // ============================================================================
-// Watch Mode Context - Encapsulates all watch mode state
+// 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;
-  lastTestFiles: TestFileInfo[];
-  hooksEnabled: boolean;
   cleanupRegistered: boolean;
   cleanupPromise: Promise<void> | null;
-  closeCliShortcuts: (() => void) | null;
-  chunkHashes: Map<string, string>;
-  affectedTestFiles: string[];
 };
 
 const watchContext: WatchContext = {
   runtime: null,
-  lastTestFiles: [],
-  hooksEnabled: false,
   cleanupRegistered: false,
   cleanupPromise: null,
-  closeCliShortcuts: null,
-  chunkHashes: new Map(),
-  affectedTestFiles: [],
 };
 
 // ============================================================================
@@ -948,42 +1009,87 @@ const getChunkKey = (chunk: StatsChunk): string | null => {
 };
 
 /**
- * Compare chunk hashes and find affected test files for watch mode re-runs.
- * Uses chunk.id/names as stable keys instead of relying on file path patterns.
+ * 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: StatsChunk[] | undefined,
-  entryTestFiles: Set<string>,
-): string[] => {
-  if (!chunks) return [];
-
-  const affectedFiles = new Set<string>();
-  const currentHashes = new Map<string, string>();
+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) {
+  for (const chunk of chunks || []) {
     if (!chunk.hash) continue;
 
-    // First check if this chunk contains a test entry file
-    const testFile = findTestFileInModules(chunk.modules, entryTestFiles);
-    if (!testFile) continue;
-
-    // Get a stable key for this chunk
     const chunkKey = getChunkKey(chunk);
     if (!chunkKey) continue;
 
-    const prevHash = watchContext.chunkHashes.get(chunkKey);
-    currentHashes.set(chunkKey, chunk.hash);
+    const testFile = findTestFileInModules(chunk.modules, entryTestFiles);
+    if (testFile) {
+      recordChunk(entryHashes, testFile, chunkKey, chunk.hash);
+      continue;
+    }
 
-    if (prevHash !== undefined && prevHash !== chunk.hash) {
-      affectedFiles.add(testFile);
-      logger.debug(
-        `[Watch] Chunk hash changed for ${chunkKey}: ${prevHash} -> ${chunk.hash} (test: ${testFile})`,
-      );
+    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);
   }
 
-  watchContext.chunkHashes = currentHashes;
-  return Array.from(affectedFiles);
+  for (const affected of outcome.affectedPaths) {
+    logger.debug(`[Watch] Chunk hash changed for test: ${affected}`);
+  }
+
+  return outcome.affectedPaths;
 };
 
 const getBrowserProjects = (context: RstestContext): ProjectContext[] =>
@@ -1413,9 +1519,6 @@ const cleanupWatchRuntime = (): Promise<void> => {
   }
 
   watchContext.cleanupPromise = (async () => {
-    watchContext.closeCliShortcuts?.();
-    watchContext.closeCliShortcuts = null;
-
     if (!watchContext.runtime) {
       return;
     }
@@ -1427,12 +1530,22 @@ const cleanupWatchRuntime = (): Promise<void> => {
   return watchContext.cleanupPromise;
 };
 
-const registerWatchCleanup = (): void => {
+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;
+  }
 
-  for (const signal of ['SIGINT', 'SIGTERM', 'SIGTSTP'] as const) {
+  // 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();
     });
@@ -1441,8 +1554,6 @@ const registerWatchCleanup = (): void => {
   process.once('exit', () => {
     void cleanupWatchRuntime();
   });
-
-  watchContext.cleanupRegistered = true;
 };
 
 const createBrowserRuntime = async ({
@@ -1502,6 +1613,10 @@ const createBrowserRuntime = async ({
   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;
@@ -1530,6 +1645,7 @@ const createBrowserRuntime = async ({
       dispatchHandlers,
       wss: undefined as unknown as WebSocketServer,
       projectEntries,
+      watchState,
     };
   };
 
@@ -1673,6 +1789,55 @@ const createBrowserRuntime = async ({
     }
   };
 
+  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,
@@ -1730,6 +1895,13 @@ const createBrowserRuntime = async ({
             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: {
@@ -1822,8 +1994,35 @@ const createBrowserRuntime = async ({
                     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:
@@ -1893,37 +2092,80 @@ const createBrowserRuntime = async ({
           name: 'rstest:browser-watch',
           setup(api) {
             api.onBeforeDevCompile(() => {
-              if (!watchContext.hooksEnabled) {
+              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) {
-                const allProjectEntries = await collectProjectEntries(context);
+                // 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(allProjectEntries).map(
+                  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(
-                  statsJson.chunks,
+                const affected = getAffectedTestFiles({
+                  chunks: statsJson.chunks,
                   entryTestFiles,
-                );
-                watchContext.affectedTestFiles = affected;
+                  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 (!watchContext.hooksEnabled) {
+              if (!watchState.hooksEnabled) {
                 return;
               }
 
@@ -1965,6 +2207,15 @@ const createBrowserRuntime = async ({
     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,
@@ -2001,43 +2252,6 @@ const createBrowserRuntime = async ({
           }
           return;
         }
-        // Container UI HTML + static assets are served by the container origin
-        // only. Per-project runner servers expose just /runner.html + assets.
-        if (isContainerServer) {
-          if (url.pathname === '/') {
-            if (await respondWithDevServerHtml(url, res)) {
-              return;
-            }
-
-            const html =
-              injectedContainerHtml ||
-              containerHtmlTemplate?.replace(OPTIONS_PLACEHOLDER, 'null');
-
-            if (html) {
-              res.setHeader('Content-Type', 'text/html');
-              res.end(html);
-              return;
-            }
-
-            res.statusCode = 502;
-            res.end('Container UI is not available.');
-            return;
-          }
-          if (url.pathname.startsWith('/container-static/')) {
-            if (await proxyDevServerAsset(req, res)) {
-              return;
-            }
-
-            if (serveContainer) {
-              serveContainer(req, res, next);
-              return;
-            }
-
-            res.statusCode = 502;
-            res.end('Container assets are not available.');
-            return;
-          }
-        }
         if (url.pathname === '/runner.html') {
           res.setHeader('Content-Type', 'text/html');
           res.end(htmlTemplate);
@@ -2114,6 +2328,7 @@ const createBrowserRuntime = async ({
       dispatchHandlers,
       wss,
       projectEntries,
+      watchState,
     };
   } catch (error) {
     wss.close();
@@ -2157,7 +2372,6 @@ export const runBrowserController = async (
   options?: BrowserTestRunOptions,
 ): Promise<BrowserTestRunResult | void> => {
   const {
-    allowEmptyWatchRun = false,
     allowEmptyRun = false,
     filesOnly = false,
     onTraceEvents,
@@ -2175,10 +2389,13 @@ export const runBrowserController = async (
   // 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.
+  // 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 —
@@ -2324,47 +2541,27 @@ export const runBrowserController = async (
 
   const notifyTestRunEnd = async ({
     duration,
-    unhandledErrors,
-    filterRerunTestPaths,
+    coverage,
   }: {
     duration: {
       totalTime: number;
       buildTime: number;
       testTime: number;
     };
-    unhandledErrors?: Error[];
-    filterRerunTestPaths?: string[];
+    coverage?: CoverageMapData;
   }): Promise<void> => {
     if (!isWatchMode) {
       return;
     }
 
-    // Merge per-file coverage into a single CoverageMapData for reporters
-    let mergedCoverage: CoverageMapData | undefined;
-    if (coverageProvider) {
-      const coverageMap = coverageProvider.createCoverageMap();
-      let hasCoverage = false;
-      for (const result of context.reporterResults.results) {
-        if (result.coverage) {
-          coverageMap.merge(result.coverage);
-          hasCoverage = true;
-        }
-      }
-      if (hasCoverage) {
-        mergedCoverage = coverageMap.toJSON();
-      }
-    }
-
     for (const reporter of context.reporters) {
       await reporter.onTestRunEnd?.({
         results: context.reporterResults.results,
-        coverage: mergedCoverage,
+        coverage,
         testResults: context.reporterResults.testResults,
         duration,
         snapshotSummary: context.snapshotManager.summary,
         getSourcemap: getBrowserSourcemap,
-        unhandledErrors,
-        filterRerunTestPaths,
       });
     }
   };
@@ -2405,7 +2602,6 @@ export const runBrowserController = async (
     (total, item) => total + item.testFiles.length,
     0,
   );
-  const shouldKeepWatchingWithEmptySet = isWatchMode && allowEmptyWatchRun;
   const shouldInitializeEmptyBrowserHooks =
     totalTests === 0 && hasUserRstestConfigPlugins(browserProjects);
 
@@ -2425,16 +2621,14 @@ export const runBrowserController = async (
     };
   };
 
-  const reportEmptyTestSet = (): boolean => {
+  const reportEmptyTestSet = (): void => {
     const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
     if (isWatchMode || !allowEmptyRun) {
-      const message = shouldKeepWatchingWithEmptySet
-        ? 'No test files found.'
-        : getNoTestFilesMessage({
-            context,
-            code,
-            defaultMessage: `No test files found, exiting with code ${code}.`,
-          });
+      const message = getNoTestFilesMessage({
+        context,
+        code,
+        defaultMessage: `No test files found, exiting with code ${code}.`,
+      });
       if (code === 0) {
         logger.log(color.yellow(message));
       } else {
@@ -2457,29 +2651,21 @@ export const runBrowserController = async (
     // In non-watch runs the host returns a void outcome and core's
     // `reportNoTestFiles` owns the exit code and the no-test reporter lifecycle;
     // the host must not set the code itself. Watch keeps its own exit code.
-    if (
-      isWatchMode &&
-      code !== 0 &&
-      !shouldKeepWatchingWithEmptySet &&
-      !allowEmptyRun
-    ) {
+    if (isWatchMode && code !== 0 && !allowEmptyRun) {
       ensureProcessExitCode(code);
     }
-
-    return !shouldKeepWatchingWithEmptySet;
   };
 
   if (totalTests === 0 && !shouldInitializeEmptyBrowserHooks) {
-    if (reportEmptyTestSet()) {
-      return allowEmptyRun ? createEmptyRunResult() : undefined;
-    }
+    reportEmptyTestSet();
+    return allowEmptyRun ? createEmptyRunResult() : undefined;
   }
 
   if (!filesOnly) {
     await notifyTestRunStart();
   }
 
-  const enableCliShortcuts = isWatchMode && isBrowserWatchCliShortcutsEnabled();
+  const enableCliShortcuts = isWatchMode && isTTY('stdin');
   const browserTempOutputRoot = context.normalizedConfig.output.distPath.root;
   const tempDir =
     isWatchMode && watchContext.runtime
@@ -2493,15 +2679,13 @@ export const runBrowserController = async (
             Date.now().toString(),
           );
 
-  // Track initial test files for watch mode
-  if (isWatchMode) {
-    watchContext.lastTestFiles = collectWatchTestFiles(projectEntries);
-  }
-
   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 {
@@ -2532,15 +2716,109 @@ export const runBrowserController = async (
 
     if (isWatchMode) {
       watchContext.runtime = runtime;
-      registerWatchCleanup();
+      registerWatchCleanup(context.embedded);
+    }
+  }
 
-      if (enableCliShortcuts && !watchContext.closeCliShortcuts) {
-        watchContext.closeCliShortcuts = await setupBrowserWatchCliShortcuts({
-          close: cleanupWatchRuntime,
-        });
+  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(
@@ -2566,7 +2844,8 @@ export const runBrowserController = async (
     };
   }
 
-  if (totalTests === 0 && reportEmptyTestSet()) {
+  if (totalTests === 0) {
+    reportEmptyTestSet();
     await destroyBrowserRuntime(runtime);
     return allowEmptyRun ? createEmptyRunResult() : undefined;
   }
@@ -2612,7 +2891,9 @@ export const runBrowserController = async (
     rootPath: normalize(context.rootPath),
     projects: projectRuntimeConfigs,
     snapshot: {
-      updateSnapshot: context.snapshotManager.options.updateSnapshot,
+      updateSnapshot:
+        options?.updateSnapshot ??
+        context.snapshotManager.options.updateSnapshot,
     },
     // Container origin (fallback). Per-project runner origins below.
     runnerUrl: `http://localhost:${runtime.containerServer.port}`,
@@ -2728,22 +3009,18 @@ export const runBrowserController = async (
       createRunnerEventSink(context, project.normalizedConfig),
     ]),
   );
-  const firstBrowserSink = runnerSinks.get(browserProjects[0]!.name)!;
-
-  // testPath -> owning project name, stamped from the authoritative client
-  // file-start event (it carries the manifest-resolved projectName) before any
-  // other per-file event for that path fires — including on watch reruns, so the
-  // mapping stays correct when a rerun adds a file. Fully eliminating this map in
-  // favor of a project stamp on every wire event is deferred (it would add
-  // `project` to the shared `TestResult`/`TestFileResult` payloads).
-  const projectNameByTestPath = new Map<string, string>();
-
-  const sinkForProjectName = (projectName: string): RunnerEventSink =>
-    runnerSinks.get(projectName) ?? firstBrowserSink;
-
-  const sinkForTestPath = (testPath: string): RunnerEventSink => {
-    const projectName = projectNameByTestPath.get(testPath);
-    return projectName ? sinkForProjectName(projectName) : firstBrowserSink;
+  // 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
@@ -2760,7 +3037,7 @@ export const runBrowserController = async (
       disableConsoleIntercept: context.normalizedConfig.disableConsoleIntercept,
     },
     emitInterceptedLog: (log) =>
-      sinkForTestPath(log.testPath).onConsoleLog(log),
+      sinkForProjectName(log.project).onConsoleLog(log),
     writeOriginalLog: () => {},
   });
 
@@ -2795,7 +3072,6 @@ export const runBrowserController = async (
   const handleTestFileStart = async (
     payload: TestFileStartPayload,
   ): Promise<void> => {
-    projectNameByTestPath.set(payload.testPath, payload.projectName);
     if (phaseTrackers) {
       const tracker = new PhaseTracker({
         trace: {
@@ -2805,13 +3081,17 @@ export const runBrowserController = async (
         pid: nextBrowserFilePid++,
       });
       tracker.transition('prepare');
-      phaseTrackers.set(payload.testPath, tracker);
+      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: [],
     });
   };
@@ -2819,22 +3099,28 @@ export const runBrowserController = async (
   const handleTestFileReady = async (
     payload: TestFileReadyPayload,
   ): Promise<void> => {
-    phaseTrackers?.get(payload.testPath)?.transition('tests');
-    await sinkForTestPath(payload.testPath).onTestFileReady(payload);
+    phaseTrackers
+      ?.get(trackerKey(payload.project, payload.testPath))
+      ?.transition('tests');
+    await sinkForProjectName(payload.project).onTestFileReady(payload);
   };
 
   const handleTestSuiteStart = async (
     payload: TestSuiteStartPayload,
   ): Promise<void> => {
-    phaseTrackers?.get(payload.testPath)?.recordSuiteStart(payload);
-    await sinkForTestPath(payload.testPath).onTestSuiteStart(payload);
+    phaseTrackers
+      ?.get(trackerKey(payload.project, payload.testPath))
+      ?.recordSuiteStart(payload);
+    await sinkForProjectName(payload.project).onTestSuiteStart(payload);
   };
 
   const handleTestSuiteResult = async (
     payload: TestSuiteResultPayload,
   ): Promise<void> => {
-    phaseTrackers?.get(payload.testPath)?.recordSuiteResult(payload);
-    await sinkForTestPath(payload.testPath).onTestSuiteResult(payload);
+    phaseTrackers
+      ?.get(trackerKey(payload.project, payload.testPath))
+      ?.recordSuiteResult(payload);
+    await sinkForProjectName(payload.project).onTestSuiteResult(payload);
 
     if (context.normalizedConfig.silent === 'passed-only') {
       silentConsoleController.flushBufferedLogsForTask({
@@ -2850,15 +3136,19 @@ export const runBrowserController = async (
   const handleTestCaseStart = async (
     payload: TestCaseStartPayload,
   ): Promise<void> => {
-    phaseTrackers?.get(payload.testPath)?.recordCaseStart(payload);
+    phaseTrackers
+      ?.get(trackerKey(payload.project, payload.testPath))
+      ?.recordCaseStart(payload);
     // Fire-and-forget on both transports (the sink does not await case-start).
-    sinkForTestPath(payload.testPath).onTestCaseStart(payload);
+    sinkForProjectName(payload.project).onTestCaseStart(payload);
   };
 
   const handleTestCaseResult = async (payload: TestResult): Promise<void> => {
     caseResults.push(payload);
-    phaseTrackers?.get(payload.testPath)?.recordCaseResult(payload);
-    await sinkForTestPath(payload.testPath).onTestCaseResult(payload);
+    phaseTrackers
+      ?.get(trackerKey(payload.project, payload.testPath))
+      ?.recordCaseResult(payload);
+    await sinkForProjectName(payload.project).onTestCaseResult(payload);
 
     if (context.normalizedConfig.silent === 'passed-only') {
       silentConsoleController.flushBufferedLogsForTask({
@@ -2878,12 +3168,13 @@ export const runBrowserController = async (
     context.updateReporterResultState([payload], payload.results);
 
     if (phaseTrackers) {
-      const tracker = phaseTrackers.get(payload.testPath);
+      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(payload.testPath);
+        phaseTrackers.delete(key);
       }
     }
 
@@ -2899,7 +3190,7 @@ export const runBrowserController = async (
 
     // Feeds stateManager, fans out onTestFileResult to reporters, and ingests
     // payload.snapshotResult (the snapshotManager.add moved into the sink).
-    await sinkForTestPath(payload.testPath).onTestFileResult(payload);
+    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') {
@@ -2917,6 +3208,7 @@ export const runBrowserController = async (
       taskParentNames: payload.taskParentNames,
       taskType: payload.taskType,
       testPath: payload.testPath,
+      project: payload.projectName,
       type: payload.type,
       trace: payload.trace,
     };
@@ -3174,6 +3466,12 @@ export const runBrowserController = async (
 
         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}`,
         };
@@ -3343,20 +3641,16 @@ export const runBrowserController = async (
             fatalError && fatalError !== fatalErrorBeforeRun
               ? fatalError
               : undefined;
-          await notifyTestRunEnd({
-            duration: {
-              totalTime: testTime,
-              buildTime: 0,
-              testTime,
-            },
-            filterRerunTestPaths: files.map((file) => file.testPath),
+          await finalizeWatchRerun({
+            rerunTestPaths: files.map((file) => file.testPath),
+            testTime,
             unhandledErrors: rerunError
               ? [rerunError]
               : rerunFatalError
                 ? [rerunFatalError]
                 : undefined,
           });
-          logBrowserWatchReadyMessage(enableCliShortcuts);
+          logWatchReadyMessage(context, enableCliShortcuts);
         }
       },
       onError: async (error) => {
@@ -3373,68 +3667,7 @@ export const runBrowserController = async (
       },
     });
 
-    if (allTestFiles.length === 0) {
-      const duration = {
-        totalTime: buildTime,
-        buildTime,
-        testTime: 0,
-      };
-      const result = {
-        results: reporterResults,
-        testResults: caseResults,
-        duration,
-        hasFailure: false,
-        getSourcemap: getBrowserSourcemap,
-        resolveSourcemap: resolveBrowserSourcemap,
-        close: !isWatchMode
-          ? async () => {
-              sessionRegistry.clear();
-              await destroyBrowserRuntime(runtime);
-            }
-          : undefined,
-      };
-
-      if (isWatchMode) {
-        await notifyTestRunEnd({ duration });
-      }
-
-      if (isWatchMode) {
-        triggerRerun = async () => {
-          const newProjectEntries = await collectProjectEntries(context);
-          const rerunPlan = planWatchRerun({
-            projectEntries: newProjectEntries,
-            previousTestFiles: watchContext.lastTestFiles,
-            affectedTestFiles: watchContext.affectedTestFiles,
-          });
-          watchContext.affectedTestFiles = [];
-
-          if (rerunPlan.filesChanged) {
-            watchContext.lastTestFiles = rerunPlan.currentTestFiles;
-            if (rerunPlan.currentTestFiles.length === 0) {
-              logger.log(
-                color.cyan('No browser test files remain after update.\n'),
-              );
-              logBrowserWatchReadyMessage(enableCliShortcuts);
-              return;
-            }
-
-            logger.log(
-              color.cyan(
-                `Test file set changed, re-running ${rerunPlan.currentTestFiles.length} file(s)...\n`,
-              ),
-            );
-            void latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
-            return;
-          }
-
-          logBrowserWatchReadyMessage(enableCliShortcuts);
-        };
-        watchContext.hooksEnabled = true;
-        logBrowserWatchReadyMessage(enableCliShortcuts);
-      }
-
-      return result;
-    }
+    awaitHeadlessRerunIdle = () => latestRerunScheduler.whenIdle();
 
     const testStart = Date.now();
     await runFilesWithPool(allTestFiles);
@@ -3445,26 +3678,25 @@ export const runBrowserController = async (
         const newProjectEntries = await collectProjectEntries(context);
         const rerunPlan = planWatchRerun({
           projectEntries: newProjectEntries,
-          previousTestFiles: watchContext.lastTestFiles,
-          affectedTestFiles: watchContext.affectedTestFiles,
+          previousTestFiles: watchState.lastTestFiles,
+          affectedTestFiles: drainPendingAffectedTestFiles(watchState),
         });
-        watchContext.affectedTestFiles = [];
 
         if (rerunPlan.filesChanged) {
           const deletedTestPaths = collectDeletedTestPaths(
-            watchContext.lastTestFiles,
+            watchState.lastTestFiles,
             rerunPlan.currentTestFiles,
           );
           if (deletedTestPaths.length > 0) {
             context.updateReporterResultState([], [], deletedTestPaths);
           }
-          watchContext.lastTestFiles = rerunPlan.currentTestFiles;
+          watchState.lastTestFiles = rerunPlan.currentTestFiles;
           if (rerunPlan.currentTestFiles.length === 0) {
             await latestRerunScheduler.enqueueLatest([]);
             logger.log(
               color.cyan('No browser test files remain after update.\n'),
             );
-            logBrowserWatchReadyMessage(enableCliShortcuts);
+            logWatchReadyMessage(context, enableCliShortcuts);
             return;
           }
 
@@ -3473,7 +3705,7 @@ export const runBrowserController = async (
               `Test file set changed, re-running ${rerunPlan.currentTestFiles.length} file(s)...\n`,
             ),
           );
-          void latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
+          await latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
           return;
         }
 
@@ -3483,7 +3715,7 @@ export const runBrowserController = async (
               'No affected browser test files detected, skipping re-run.\n',
             ),
           );
-          logBrowserWatchReadyMessage(enableCliShortcuts);
+          logWatchReadyMessage(context, enableCliShortcuts);
           return;
         }
 
@@ -3492,7 +3724,7 @@ export const runBrowserController = async (
             `Re-running ${rerunPlan.affectedTestFiles.length} affected test file(s)...\n`,
           ),
         );
-        void latestRerunScheduler.enqueueLatest(rerunPlan.affectedTestFiles);
+        await latestRerunScheduler.enqueueLatest(rerunPlan.affectedTestFiles);
       };
     }
 
@@ -3524,6 +3756,15 @@ export const runBrowserController = async (
       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,
@@ -3534,19 +3775,26 @@ export const runBrowserController = async (
       // `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 });
+        await notifyTestRunEnd({
+          duration,
+          coverage: cycleCoverageMap?.files().length
+            ? cycleCoverageMap.toJSON()
+            : undefined,
+        });
       } finally {
         await closeHeadlessRuntime?.();
       }
     }
 
     if (isWatchMode && triggerRerun) {
-      watchContext.hooksEnabled = true;
-      logBrowserWatchReadyMessage(enableCliShortcuts);
+      watchState.hooksEnabled = true;
+      logWatchReadyMessage(context, enableCliShortcuts);
     }
 
     return result;
@@ -3924,30 +4172,43 @@ export const runBrowserController = async (
   // Define rerun logic for watch mode
   if (isWatchMode) {
     triggerRerun = async () => {
-      const newProjectEntries = await collectProjectEntries(context);
+      // 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: watchContext.lastTestFiles,
-        affectedTestFiles: watchContext.affectedTestFiles,
+        previousTestFiles: watchState.lastTestFiles,
+        affectedTestFiles: drainPendingAffectedTestFiles(watchState),
       });
-      watchContext.affectedTestFiles = [];
 
       if (rerunPlan.filesChanged) {
         const deletedTestPaths = collectDeletedTestPaths(
-          watchContext.lastTestFiles,
+          watchState.lastTestFiles,
           rerunPlan.currentTestFiles,
         );
         if (deletedTestPaths.length > 0) {
           context.updateReporterResultState([], [], deletedTestPaths);
         }
-        watchContext.lastTestFiles = rerunPlan.currentTestFiles;
+        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'),
           );
-          logBrowserWatchReadyMessage(enableCliShortcuts);
+          logWatchReadyMessage(context, enableCliShortcuts);
           return;
         }
         await waitForRunnerFramesReady(
@@ -3984,26 +4245,22 @@ export const runBrowserController = async (
             fatalError && fatalError !== fatalErrorBeforeRun
               ? fatalError
               : undefined;
-          await notifyTestRunEnd({
-            duration: {
-              totalTime: testTime,
-              buildTime: 0,
-              testTime,
-            },
-            filterRerunTestPaths: rerunPlan.normalizedAffectedTestFiles,
+          await finalizeWatchRerun({
+            rerunTestPaths: rerunPlan.normalizedAffectedTestFiles,
+            testTime,
             unhandledErrors: rerunError
               ? [rerunError]
               : rerunFatalError
                 ? [rerunFatalError]
                 : undefined,
           });
-          logBrowserWatchReadyMessage(enableCliShortcuts);
+          logWatchReadyMessage(context, enableCliShortcuts);
         }
       } else if (!rerunPlan.filesChanged) {
         logger.log(color.cyan('Tests will be re-executed automatically\n'));
-        logBrowserWatchReadyMessage(enableCliShortcuts);
+        logWatchReadyMessage(context, enableCliShortcuts);
       } else {
-        logBrowserWatchReadyMessage(enableCliShortcuts);
+        logWatchReadyMessage(context, enableCliShortcuts);
       }
     };
   }
@@ -4045,6 +4302,12 @@ export const runBrowserController = async (
     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,
@@ -4055,11 +4318,18 @@ export const runBrowserController = async (
     // `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 });
+      await notifyTestRunEnd({
+        duration,
+        coverage: cycleCoverageMap?.files().length
+          ? cycleCoverageMap.toJSON()
+          : undefined,
+      });
     } finally {
       await closeContainerRuntime?.();
     }
@@ -4067,8 +4337,8 @@ export const runBrowserController = async (
 
   // Enable watch hooks AFTER initial test run to avoid duplicate runs
   if (isWatchMode && triggerRerun) {
-    watchContext.hooksEnabled = true;
-    logBrowserWatchReadyMessage(enableCliShortcuts);
+    watchState.hooksEnabled = true;
+    logWatchReadyMessage(context, enableCliShortcuts);
   }
 
   return result;