@rstest/browser 0.11.4 → 0.11.6

package/src/hostPayloads.ts

@@ -0,0 +1,62 @@
+import type { Reporter, TestFileResult } from '@rstest/core/internal/browser';
+import type { BrowserLogPayload } from './protocol';
+
+/** Payload for test file start event */
+export type TestFileStartPayload = {
+  testPath: string;
+  projectName: string;
+};
+
+/** Payload for log event — single-sourced from the wire protocol. */
+export type LogPayload = BrowserLogPayload;
+
+/** Payload for fatal error event */
+export type FatalPayload = {
+  message: string;
+  stack?: string;
+};
+
+export type ReporterHookArg<THook extends keyof Reporter> =
+  NonNullable<Reporter[THook]> extends (...args: infer TArgs) => unknown
+    ? TArgs[0]
+    : never;
+
+export type TestFileReadyPayload = ReporterHookArg<'onTestFileReady'>;
+export type TestSuiteStartPayload = ReporterHookArg<'onTestSuiteStart'>;
+export type TestSuiteResultPayload = ReporterHookArg<'onTestSuiteResult'>;
+export type TestCaseStartPayload = ReporterHookArg<'onTestCaseStart'>;
+export type ReloadTestFileAck = {
+  runId: string;
+};
+export type HeadedTestFileCompletePayload = TestFileResult & {
+  runId?: string;
+};
+
+export type DeferredPromise<T> = {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason?: unknown) => void;
+};
+
+export const getFileTaskId = (testPath: string): string => {
+  return `file:${testPath}`;
+};
+
+export const toError = (error: unknown): Error => {
+  return error instanceof Error ? error : new Error(String(error));
+};
+
+export 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,
+  };
+};

package/src/protocol.ts

@@ -69,6 +69,12 @@ export type BrowserExecutionMode = 'run' | 'collect';
 export type BrowserLogPayload = {
   level: 'log' | 'warn' | 'error' | 'info' | 'debug';
   content: string;
+  /**
+   * Owning project, resolved by the client from its manifest. The host must
+   * not re-derive it from `testPath` — concurrent projects can run the same
+   * file, so a path-keyed lookup can attribute the log to the wrong project.
+   */
+  projectName: string;
   taskId?: string;
   taskName?: string;
   taskParentNames?: string[];

package/src/schedulerSeam.ts

@@ -0,0 +1,49 @@
+import type { ExecutorCycleOutcome } from '@rstest/core/internal/browser';
+import type { BrowserDispatchRequest } from './protocol';
+import type { BrowserProviderPage } from './providers';
+
+/**
+ * The contract between the controller and whichever run branch executes a run.
+ * It lives outside both so the schedulers never reach back into the controller
+ * for a type: the controller owns the run's shape, the schedulers own the run.
+ */
+
+/**
+ * The watch-session control surface a watch-mode controller run hands back with
+ * its initial cycle. Every rerun trigger the host owns (dev rebuild, HMR, the
+ * in-page rerun button) resolves its own scope and then signals core's
+ * invalidation subscriber; core resets the cycle state and calls back into
+ * {@link BrowserWatchSession.runCycle} to execute it. A trigger that resolves to
+ * no work never signals, so a scope matching none of this host's files produces
+ * no cycle and no cycle output.
+ */
+export type BrowserWatchSession = {
+  /** Execute the scope the last trigger resolved, as one cycle outcome. */
+  runCycle: (testPaths: string[]) => Promise<ExecutorCycleOutcome>;
+  /** Explicit path-scoped rerun request (a CLI shortcut's browser fanout). */
+  requestRerun: (testPaths?: string[]) => Promise<void>;
+};
+
+/**
+ * What a run branch produces. Results and errors accumulate in the sinks the
+ * controller owns, so a scheduler reports only what it alone knows: how long
+ * the tests took, the session it left behind, and how to tear down a runtime
+ * that does not outlive the run.
+ */
+export type SchedulerRunResult = {
+  testTime: number;
+  watchSession?: BrowserWatchSession;
+  close?: () => Promise<void>;
+};
+
+/**
+ * How the shared dispatch layer reaches the pages of whichever run branch is
+ * live. Only the running branch knows its pages, so it installs the resolver
+ * and the dispatch layer stays branch-agnostic.
+ */
+export type DispatchPageResolver = (
+  target?: BrowserDispatchRequest['target'],
+) => {
+  runnerPage?: BrowserProviderPage;
+  containerPage?: BrowserProviderPage;
+};

package/src/watchRerunPlanner.ts

@@ -1,6 +1,21 @@
 import { normalize } from 'pathe';
 import type { TestFileInfo } from './protocol';
 
+/**
+ * Paths the previous cycle ran that the current file set no longer contains.
+ * Core prunes its own state from this, so a file deleted mid-session stops
+ * being reported instead of lingering as a passing result.
+ */
+export 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));
+};
+
 type WatchPlannerProjectEntry = {
   project: {
     name: string;
@@ -59,15 +74,11 @@ export const planWatchRerun = ({
   const normalizedAffectedTestFiles = affectedTestFiles.map((testFile) =>
     normalize(testFile),
   );
-
-  const currentFileMap = new Map(
-    currentTestFiles.map((file) => [file.testPath, file] as const),
+  const affectedPathSet = new Set(normalizedAffectedTestFiles);
+  const matchedAffectedFiles = currentTestFiles.filter((file) =>
+    affectedPathSet.has(file.testPath),
   );
 
-  const matchedAffectedFiles = normalizedAffectedTestFiles
-    .map((testFile) => currentFileMap.get(testFile))
-    .filter((file): file is TestFileInfo => Boolean(file));
-
   return {
     currentTestFiles,
     filesChanged,

package/src/watchRuntime.ts

@@ -0,0 +1,83 @@
+import { FATAL_SIGNALS } from '@rstest/core/internal/browser';
+import { destroyBrowserRuntime, type BrowserRuntime } from './browserRsbuild';
+
+// 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`.
+export type WatchContext = {
+  runtime: BrowserRuntime | null;
+  cleanupRegistered: boolean;
+  cleanupPromise: Promise<void> | null;
+};
+
+export const watchContext: WatchContext = {
+  runtime: null,
+  cleanupRegistered: false,
+  cleanupPromise: null,
+};
+
+/**
+ * Tear down the persistent watch runtime (dev servers, provider, browser,
+ * WebSocket server). Idempotent, and the single teardown the browser executor's
+ * `close` and the process-exit nets both go through.
+ */
+export const runWatchRuntimeTeardown = <T>(
+  state: { runtime: T | null; cleanupPromise: Promise<void> | null },
+  destroy: (runtime: T) => Promise<void>,
+): Promise<void> => {
+  if (state.cleanupPromise) {
+    return state.cleanupPromise;
+  }
+
+  state.cleanupPromise = (async () => {
+    if (!state.runtime) {
+      return;
+    }
+
+    await destroy(state.runtime);
+    state.runtime = null;
+  })();
+
+  // The memo is released once this teardown settles, because the state outlives
+  // the session: a config-file change restarts the run against a fresh runtime,
+  // and a memo left resolved from the previous session would make every later
+  // teardown a no-op — leaving the session after that to reuse a runtime built
+  // from the pre-restart config. Idempotency only has to hold within a runtime.
+  return state.cleanupPromise.finally(() => {
+    state.cleanupPromise = null;
+  });
+};
+
+export const cleanupWatchRuntime = (): Promise<void> =>
+  // `cleanupRegistered` is deliberately not re-armed alongside the memo: the
+  // signal nets it installs read `watchContext.runtime` live, so they stay
+  // correct across a restart, and re-registering would stack a fresh set of
+  // listeners on every one.
+  runWatchRuntimeTeardown(watchContext, destroyBrowserRuntime);
+
+export 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 browser executor's `close` instead of signals.
+  if (embedded) {
+    return;
+  }
+
+  // Cleanup-only nets: core's watch loop owns the signal → exit-code path and
+  // awaits the same idempotent `cleanupWatchRuntime` promise through the
+  // browser executor's `close`.
+  for (const signal of FATAL_SIGNALS) {
+    process.once(signal, () => {
+      void cleanupWatchRuntime();
+    });
+  }
+
+  process.once('exit', () => {
+    void cleanupWatchRuntime();
+  });
+};

package/src/watchSignals.ts

@@ -0,0 +1,93 @@
+import {
+  color,
+  type ExecutorInvalidationCallback,
+  logger,
+} from '@rstest/core/internal/browser';
+
+/**
+ * The handover between this host's rerun triggers and core's watch-cycle
+ * driver. Triggers reach it from three unrelated places — the bundler's
+ * dev-compile hook, a CLI shortcut's fanout, the in-page rerun button — and
+ * only the ordering inside `signalInvalidation` keeps them from racing each
+ * other. Each run branch installs the pieces it owns; nothing here knows which
+ * branch is running.
+ */
+export type WatchSignals = ReturnType<typeof createWatchSignals>;
+
+export const createWatchSignals = (
+  onInvalidate: ExecutorInvalidationCallback | undefined,
+) => {
+  // The transport-owned rerun trigger, installed by whichever run branch
+  // (headless/headed) is driving this run: resolve this rebuild's scope, then
+  // hand it to core's invalidation subscriber. Populated after the initial
+  // cycle.
+  let dispatchRerun: (() => Promise<void>) | undefined;
+
+  /**
+   * Latest-wins interrupt, installed by the run branch whose in-flight run can
+   * be cut short (headless). Core serializes cycles, so a trigger arriving
+   * mid-cycle would otherwise wait out a run the user has already superseded.
+   */
+  let interruptInFlightRun: (() => Promise<void>) | undefined;
+
+  /**
+   * The cycle core is running for the scope last signalled. Only an explicit
+   * request awaits it, right after it dispatched: a CLI shortcut's
+   * `updateSnapshot` stays flipped only until `requestRerun` resolves, and the
+   * in-page rerun button answers its RPC when the rerun is done. A rejection is
+   * reported here rather than left to an awaiting caller, because compile-driven
+   * triggers have no caller — and a failed cycle must not end the session.
+   */
+  let signalledCycle: Promise<void> | undefined;
+
+  return {
+    setDispatchRerun(fn: () => Promise<void>): void {
+      dispatchRerun = fn;
+    },
+    async runDispatchRerun(): Promise<void> {
+      await dispatchRerun?.();
+    },
+    setInterrupt(fn: () => Promise<void>): void {
+      interruptInFlightRun = fn;
+    },
+    /**
+     * Hand the scope this trigger resolved to core, which resets the cycle state,
+     * calls back into the session's `runCycle`, and finalizes.
+     *
+     * The cycle is deliberately *not* awaited here. Rebuild triggers reach this
+     * from inside the bundler's dev-compile hook, and the bundler keeps no
+     * watcher attached while that hook is pending: anything created or deleted in
+     * that window is never seen, so it never rebuilds and never reruns. Holding
+     * the hook for a whole cycle widens that blind window to the cycle's full
+     * duration, which loses test files added or removed mid-run for good. Core
+     * serializes the cycles itself, so nothing here has to.
+     *
+     * The in-flight run is cut short here rather than at the trigger, because only
+     * this point knows a replacement cycle is actually coming: a trigger that
+     * resolves to no affected files must leave the running cycle alone, or it
+     * finalizes on results it never produced.
+     */
+    async signalInvalidation(
+      fileFilters: string[],
+      /**
+       * Run state this trigger binds to its own paths, taken in the same turn as
+       * the handover — after any interrupt, so no queued cycle can be dequeued in
+       * between and read it. The headed rerun's per-file test-name pattern is the
+       * one such state; core's cycle options cannot carry it, so the only thing
+       * that makes it the property of one cycle is claiming it here.
+       */
+      claimScope?: () => void,
+    ): Promise<void> {
+      await interruptInFlightRun?.();
+      claimScope?.();
+      signalledCycle = Promise.resolve(
+        onInvalidate?.({ isFirstBuild: false, fileFilters }),
+      ).catch((error) => {
+        logger.error(color.red('Browser Mode watch cycle failed:'), error);
+      });
+    },
+    async awaitSignalledCycle(): Promise<void> {
+      await signalledCycle;
+    },
+  };
+};