@rstest/browser 0.10.2 → 0.10.4

package/src/protocol.ts

@@ -1,15 +1,18 @@
-import type { DevicePreset } from '@rstest/core/browser';
+import type { BrowserViewport } from '@rstest/core/internal/browser';
 import type {
   RuntimeConfig,
   TestFileResult,
   TestInfo,
   TestResult,
-} from '@rstest/core/browser-runtime';
+} from '@rstest/core/internal/browser-runtime';
 import type { SnapshotUpdateState } from '@vitest/snapshot';
 
 export type {
   BrowserLocatorIR,
   BrowserRpcRequest,
+  SnapshotRpcCall,
+  SnapshotRpcMethod,
+  SnapshotRpcMethodArgs,
   SnapshotRpcRequest,
 } from './rpcProtocol';
 export { validateBrowserRpcRequest } from './rpcProtocol';
@@ -27,12 +30,10 @@ export const DISPATCH_METHOD_RPC = 'rpc';
 
 export type SerializedRuntimeConfig = RuntimeConfig;
 
-export type BrowserViewport =
-  | {
-      width: number;
-      height: number;
-    }
-  | DevicePreset;
+// `BrowserViewport` is a core config type (`@rstest/core` owns the canonical
+// definition used by `NormalizedBrowserModeConfig`). Re-export it so the host
+// assigns the SAME type across the seam instead of a hand-copied duplicate.
+export type { BrowserViewport };
 
 export type BrowserProjectRuntime = {
   name: string;
@@ -58,6 +59,25 @@ export type TestFileInfo = {
  */
 export type BrowserExecutionMode = 'run' | 'collect';
 
+/**
+ * Wire shape of a `log` client message payload. The host receives this and maps
+ * it onto core's {@link UserConsoleLog} (notably `level` → `name`); that mapper
+ * (`hostController.ts` `handleLog`) annotates its result as `UserConsoleLog`, so
+ * the map→core direction is compiler-checked. Owning the wire shape here as one
+ * named type keeps the host's input type from drifting away from the producer.
+ */
+export type BrowserLogPayload = {
+  level: 'log' | 'warn' | 'error' | 'info' | 'debug';
+  content: string;
+  taskId?: string;
+  taskName?: string;
+  taskParentNames?: string[];
+  taskType?: 'file' | 'suite' | 'case';
+  testPath: string;
+  type: 'stdout' | 'stderr';
+  trace?: string;
+};
+
 export type BrowserHostConfig = {
   rootPath: string;
   projects: BrowserProjectRuntime[];
@@ -101,20 +121,7 @@ export type BrowserClientMessage =
     }
   | { type: 'case-result'; payload: TestResult }
   | { type: 'file-complete'; payload: TestFileResult }
-  | {
-      type: 'log';
-      payload: {
-        level: 'log' | 'warn' | 'error' | 'info' | 'debug';
-        content: string;
-        taskId?: string;
-        taskName?: string;
-        taskParentNames?: string[];
-        taskType?: 'file' | 'suite' | 'case';
-        testPath: string;
-        type: 'stdout' | 'stderr';
-        trace?: string;
-      };
-    }
+  | { type: 'log'; payload: BrowserLogPayload }
   | {
       type: 'fatal';
       payload: { message: string; stack?: string };
@@ -134,6 +141,38 @@ export type BrowserClientMessage =
       payload: BrowserDispatchRequest;
     };
 
+/**
+ * Lifecycle methods the runner emits via `dispatchRunnerLifecycle()` as
+ * dispatch-rpc-requests on the `runner` namespace (as opposed to the
+ * {@link BrowserClientMessage} types it `send()`s). The runner client imports
+ * this instead of redeclaring the list, so the emit site cannot drift from the
+ * host router.
+ */
+export type RunnerLifecycleMethod =
+  | 'file-ready'
+  | 'suite-start'
+  | 'suite-result'
+  | 'case-start';
+
+/**
+ * {@link BrowserClientMessage} types that are forwarded to the `runner`
+ * namespace (by message `type`) rather than handled at the transport layer.
+ * `Extract` keeps this a checked subset of the message union — renaming a
+ * message type drops it here, surfacing as a missing handler downstream.
+ */
+type RunnerMessageMethod = Extract<
+  BrowserClientMessage['type'],
+  'file-start' | 'case-result' | 'file-complete' | 'log' | 'fatal'
+>;
+
+/**
+ * Single source of truth for every method handled by the `runner` dispatch
+ * namespace. The host handler table is keyed by this union (a missing key is a
+ * compile error), so adding a runner method here forces a matching handler and
+ * cannot silently no-op at runtime.
+ */
+export type RunnerDispatchMethod = RunnerLifecycleMethod | RunnerMessageMethod;
+
 /**
  * Transport-agnostic envelope used by host routing.
  * `namespace + method + args + target` describes an operation independent of
@@ -147,6 +186,11 @@ export type BrowserDispatchRequest = {
   namespace: string;
   method: string;
   args?: unknown;
+  // Routing reads `namespace`, `method`, `runToken`, and `target.sessionId`
+  // (see dispatchRouter.ts / dispatchBrowserRpcRequest). `target.testFile` and
+  // `target.projectName` are carried for diagnostics / forward-compatibility and
+  // are NOT consulted for routing today — adding a routing-relevant field here
+  // means wiring a reader on the host side, which structural typing won't force.
   target?: {
     testFile?: string;
     sessionId?: string;

package/src/providers/index.ts

@@ -1,3 +1,4 @@
+import type { BrowserProvider } from '@rstest/core/internal/browser';
 import type { BrowserRpcRequest } from '../rpcProtocol';
 import { playwrightProviderImplementation } from './playwright';
 
@@ -14,8 +15,14 @@ import { playwrightProviderImplementation } from './playwright';
  * - do not reference optional peer provider types from public declarations
  * - keep provider-specific behavior and config decoding inside provider implementations
  * - prefer direct passthrough to provider APIs over provider-specific translation
+ *
+ * The provider-name union is owned by `@rstest/core` (see `BROWSER_PROVIDERS`)
+ * because core's CLI `init` templates need it but cannot import this package
+ * (peer-dependency direction). `providerImplementations` below is keyed by the
+ * re-exported union, so a provider added in core without an implementation here
+ * is a compile error.
  */
-export type BrowserProvider = 'playwright';
+export type { BrowserProvider };
 
 /** Minimal console shape needed by host logging bridge. */
 export type BrowserConsoleMessage = {
@@ -44,6 +51,7 @@ export type BrowserProviderPage = {
     ): void;
   };
   close: () => Promise<void>;
+  [Symbol.asyncDispose]: () => Promise<void>;
 };
 
 /** Minimal browser context API surface required by hostController. */
@@ -51,11 +59,13 @@ export type BrowserProviderContext = {
   newPage: () => Promise<BrowserProviderPage>;
   on: (event: 'page', listener: (page: BrowserProviderPage) => void) => void;
   close: () => Promise<void>;
+  [Symbol.asyncDispose]: () => Promise<void>;
 };
 
 /** Minimal browser API surface required by hostController. */
 export type BrowserProviderBrowser = {
   close: () => Promise<void>;
+  [Symbol.asyncDispose]: () => Promise<void>;
   newContext: (options: {
     viewport: { width: number; height: number } | null;
     providerOptions?: Record<string, unknown>;

package/src/providers/playwright/runtime.ts

@@ -1,4 +1,104 @@
-import type { BrowserProviderContext, BrowserProviderRuntime } from '../index';
+import type {
+  BrowserConsoleMessage,
+  BrowserProviderContext,
+  BrowserProviderPage,
+  BrowserProviderRuntime,
+} from '../index';
+
+type PlaywrightPageLike = Omit<
+  BrowserProviderPage,
+  'on' | typeof Symbol.asyncDispose
+> & {
+  on: {
+    (event: 'popup', listener: (page: PlaywrightPageLike) => void): void;
+    (
+      event: 'console',
+      listener: (message: BrowserConsoleMessage) => void,
+    ): void;
+  };
+};
+type PlaywrightContextLike = Omit<
+  BrowserProviderContext,
+  'newPage' | typeof Symbol.asyncDispose
+> & {
+  newPage: () => Promise<PlaywrightPageLike>;
+};
+
+type AsyncDisposableResource<T> = T & {
+  [Symbol.asyncDispose]: () => Promise<void>;
+};
+
+type PlaywrightBrowserLike = Omit<
+  BrowserProviderRuntime['browser'],
+  typeof Symbol.asyncDispose
+>;
+
+const patchedPages = new WeakSet<PlaywrightPageLike>();
+const patchedContexts = new WeakSet<PlaywrightContextLike>();
+
+const withAsyncDispose = <T extends { close: () => Promise<void> }>(
+  resource: T,
+): AsyncDisposableResource<T> => {
+  if (typeof Symbol.asyncDispose === 'symbol') {
+    const existing = Object.getOwnPropertyDescriptor(
+      resource,
+      Symbol.asyncDispose,
+    );
+    if (!existing) {
+      Object.defineProperty(resource, Symbol.asyncDispose, {
+        configurable: true,
+        value: () => resource.close(),
+      });
+    }
+  }
+
+  return resource as AsyncDisposableResource<T>;
+};
+
+const wrapPage = (page: PlaywrightPageLike): BrowserProviderPage => {
+  if (patchedPages.has(page)) {
+    return withAsyncDispose(page) as BrowserProviderPage;
+  }
+
+  patchedPages.add(page);
+  const originalOn = page.on.bind(page);
+  page.on = ((
+    event: 'popup' | 'console',
+    listener:
+      | ((page: BrowserProviderPage) => void)
+      | ((message: BrowserConsoleMessage) => void),
+  ) => {
+    if (event === 'popup') {
+      originalOn(event, (popup) => {
+        (listener as (page: BrowserProviderPage) => void)(wrapPage(popup));
+      });
+      return;
+    }
+
+    originalOn(event, listener as (message: BrowserConsoleMessage) => void);
+  }) as PlaywrightPageLike['on'];
+
+  return withAsyncDispose(page) as BrowserProviderPage;
+};
+
+const wrapContext = (
+  context: PlaywrightContextLike,
+): BrowserProviderContext => {
+  if (patchedContexts.has(context)) {
+    return withAsyncDispose(context) as BrowserProviderContext;
+  }
+
+  patchedContexts.add(context);
+  const originalNewPage = context.newPage.bind(context);
+  context.newPage = async () => wrapPage(await originalNewPage());
+
+  const originalOn = context.on.bind(context);
+  context.on = (event, listener) => {
+    originalOn(event, (page) => listener(wrapPage(page)));
+  };
+
+  return withAsyncDispose(context) as BrowserProviderContext;
+};
 
 export async function launchPlaywrightBrowser({
   browserName,
@@ -30,7 +130,7 @@ export async function launchPlaywrightBrowser({
     args: launchArgs,
   });
 
-  const wrappedBrowser: BrowserProviderRuntime['browser'] = {
+  const wrappedBrowser = withAsyncDispose({
     close: async () => browser.close(),
     newContext: async ({
       providerOptions: contextProviderOptions,
@@ -44,9 +144,9 @@ export async function launchPlaywrightBrowser({
         viewport,
       });
 
-      return context as unknown as BrowserProviderContext;
+      return wrapContext(context as unknown as PlaywrightContextLike);
     },
-  };
+  } satisfies PlaywrightBrowserLike) as BrowserProviderRuntime['browser'];
 
   return {
     browser: wrappedBrowser,

package/src/rpcProtocol.ts

@@ -178,28 +178,41 @@ export const validateBrowserRpcRequest = (
   return request;
 };
 
+/**
+ * Single source of truth for snapshot RPC methods and their argument shapes.
+ * The request union, the client sender, both host-side mappers, and every
+ * exhaustiveness check derive from this map — adding or renaming a method here
+ * forces a compile error at every site that has not been updated.
+ */
+export type SnapshotRpcMethodArgs = {
+  resolveSnapshotPath: { testPath: string };
+  readSnapshotFile: { filepath: string };
+  saveSnapshotFile: { filepath: string; content: string };
+  removeSnapshotFile: { filepath: string };
+};
+
+export type SnapshotRpcMethod = keyof SnapshotRpcMethodArgs;
+
 /**
  * Snapshot RPC request from runner iframe.
  * The container will forward these to the host via WebSocket RPC.
  */
-export type SnapshotRpcRequest =
-  | {
-      id: string;
-      method: 'resolveSnapshotPath';
-      args: { testPath: string };
-    }
-  | {
-      id: string;
-      method: 'readSnapshotFile';
-      args: { filepath: string };
-    }
-  | {
-      id: string;
-      method: 'saveSnapshotFile';
-      args: { filepath: string; content: string };
-    }
-  | {
-      id: string;
-      method: 'removeSnapshotFile';
-      args: { filepath: string };
-    };
+export type SnapshotRpcRequest = {
+  [M in SnapshotRpcMethod]: {
+    id: string;
+    method: M;
+    args: SnapshotRpcMethodArgs[M];
+  };
+}[SnapshotRpcMethod];
+
+/**
+ * Client-side snapshot RPC call (request without the transport `id`).
+ * Distributive over {@link SnapshotRpcMethod} so `method` and `args` stay paired
+ * at the call site — a mismatched pair fails to compile.
+ */
+export type SnapshotRpcCall = {
+  [M in SnapshotRpcMethod]: {
+    method: M;
+    args: SnapshotRpcMethodArgs[M];
+  };
+}[SnapshotRpcMethod];

package/src/viewportPresets.ts

@@ -4,6 +4,11 @@
  * IMPORTANT: Keep this list/map in sync with `DevicePreset` typing in
  * `@rstest/core` (`packages/core/src/types/config.ts`) so `defineConfig`
  * autocomplete and runtime validation stay consistent.
+ *
+ * Upstream source of truth for ids/dimensions is the Chrome DevTools emulated
+ * device list — mirror each device's `screen.vertical` `{ width, height }`:
+ * https://github.com/ChromeDevTools/devtools-frontend/blob/main/front_end/models/emulation/EmulatedDevices.ts
+ * Last verified in sync (all 17): 2026-04-22, devtools-frontend commit abaac05e.
  */
 export const BROWSER_VIEWPORT_PRESET_IDS = [
   'iPhoneSE',

package/src/watchCliShortcuts.ts

@@ -1,8 +1,6 @@
-import { color, logger } from '@rstest/core/browser';
+import { color, isTTY, logger } from '@rstest/core/internal/browser';
 
-const isTTY = (): boolean => Boolean(process.stdin.isTTY && !process.env.CI);
-
-export const isBrowserWatchCliShortcutsEnabled = (): boolean => isTTY();
+export const isBrowserWatchCliShortcutsEnabled = (): boolean => isTTY('stdin');
 
 export const getBrowserWatchCliShortcutsHintMessage = (): string => {
   return `  ${color.dim('press')} ${color.bold('q')} ${color.dim('to quit')}\n`;

package/dist/browser-container/container-static/js/188.480c3c49b5.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! LICENSE: 188.480c3c49b5.js.LICENSE.txt */

package/dist/browser-container/container-static/js/lib-react.5ae9b90ee5.js.LICENSE.txt

@@ -1 +0,0 @@
-/*! LICENSE: lib-react.5ae9b90ee5.js.LICENSE.txt */