@rstest/browser 0.10.2 → 0.10.4

package/dist/protocol.d.ts

@@ -1,7 +1,7 @@
-import type { DevicePreset } from '@rstest/core/browser';
-import type { RuntimeConfig, TestFileResult, TestInfo, TestResult } from '@rstest/core/browser-runtime';
+import type { BrowserViewport } from '@rstest/core/internal/browser';
+import type { RuntimeConfig, TestFileResult, TestInfo, TestResult } from '@rstest/core/internal/browser-runtime';
 import type { SnapshotUpdateState } from '@vitest/snapshot';
-export type { BrowserLocatorIR, BrowserRpcRequest, SnapshotRpcRequest, } from './rpcProtocol.js';
+export type { BrowserLocatorIR, BrowserRpcRequest, SnapshotRpcCall, SnapshotRpcMethod, SnapshotRpcMethodArgs, SnapshotRpcRequest, } from './rpcProtocol.js';
 export { validateBrowserRpcRequest } from './rpcProtocol.js';
 export declare const DISPATCH_MESSAGE_TYPE = "__rstest_dispatch__";
 export declare const DISPATCH_RESPONSE_TYPE = "__rstest_dispatch_response__";
@@ -13,10 +13,7 @@ export declare const DISPATCH_NAMESPACE_BROWSER = "browser";
 export declare const DISPATCH_NAMESPACE_SNAPSHOT = "snapshot";
 export declare const DISPATCH_METHOD_RPC = "rpc";
 export type SerializedRuntimeConfig = RuntimeConfig;
-export type BrowserViewport = {
-    width: number;
-    height: number;
-} | DevicePreset;
+export type { BrowserViewport };
 export type BrowserProjectRuntime = {
     name: string;
     environmentName: string;
@@ -38,6 +35,24 @@ export type TestFileInfo = {
  * - 'collect': Only collect test metadata without running
  */
 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[];
@@ -88,17 +103,7 @@ export type BrowserClientMessage = {
     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;
-    };
+    payload: BrowserLogPayload;
 } | {
     type: 'fatal';
     payload: {
@@ -120,6 +125,28 @@ export type BrowserClientMessage = {
     type: typeof DISPATCH_RPC_REQUEST_TYPE;
     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

package/dist/providers/index.d.ts

@@ -1,3 +1,4 @@
+import type { BrowserProvider } from '@rstest/core/internal/browser';
 import type { BrowserRpcRequest } from '../rpcProtocol.js';
 /**
  * Browser provider contract hub.
@@ -12,8 +13,14 @@ import type { BrowserRpcRequest } from '../rpcProtocol.js';
  * - 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 = {
     text: () => string;
@@ -39,16 +46,19 @@ export type BrowserProviderPage = {
         (event: 'console', listener: (message: BrowserConsoleMessage) => void): void;
     };
     close: () => Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
 };
 /** Minimal browser context API surface required by hostController. */
 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;

package/dist/rpcProtocol.d.ts

@@ -101,32 +101,46 @@ export type BrowserRpcRequest = {
 };
 export declare const validateBrowserRpcRequest: (payload: unknown) => BrowserRpcRequest;
 /**
- * Snapshot RPC request from runner iframe.
- * The container will forward these to the host via WebSocket RPC.
+ * 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 SnapshotRpcRequest = {
-    id: string;
-    method: 'resolveSnapshotPath';
-    args: {
+export type SnapshotRpcMethodArgs = {
+    resolveSnapshotPath: {
         testPath: string;
     };
-} | {
-    id: string;
-    method: 'readSnapshotFile';
-    args: {
+    readSnapshotFile: {
         filepath: string;
     };
-} | {
-    id: string;
-    method: 'saveSnapshotFile';
-    args: {
+    saveSnapshotFile: {
         filepath: string;
         content: string;
     };
-} | {
-    id: string;
-    method: 'removeSnapshotFile';
-    args: {
+    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 = {
+    [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/dist/rslib-runtime.js

@@ -20,11 +20,15 @@ __webpack_require__.m = __webpack_modules__;
     };
 })();
 (()=>{
-    __webpack_require__.d = (exports, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
-            enumerable: true,
-            get: definition[key]
-        });
+    __webpack_require__.d = (exports, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
     };
 })();
 (()=>{

package/dist/viewportPresets.d.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 declare const BROWSER_VIEWPORT_PRESET_IDS: readonly ['iPhoneSE', 'iPhoneXR', 'iPhone12Pro', 'iPhone14ProMax', 'Pixel7', 'SamsungGalaxyS8Plus', 'SamsungGalaxyS20Ultra', 'iPadMini', 'iPadAir', 'iPadPro', 'SurfacePro7', 'SurfaceDuo', 'GalaxyZFold5', 'AsusZenbookFold', 'SamsungGalaxyA51A71', 'NestHub', 'NestHubMax'];
 type BrowserViewportPresetId = (typeof BROWSER_VIEWPORT_PRESET_IDS)[number];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rstest/browser",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "description": "Browser mode support for Rstest testing framework.",
   "keywords": [
     "rstest",
@@ -45,25 +45,25 @@
     "open-editor": "^6.0.0",
     "pathe": "^2.0.3",
     "sirv": "^3.0.2",
-    "ws": "^8.20.1"
+    "ws": "^8.21.0"
   },
   "devDependencies": {
-    "@rslib/core": "0.21.5",
+    "@rslib/core": "0.22.0",
     "@types/convert-source-map": "^2.0.3",
     "@types/picomatch": "^4.0.3",
     "@types/ws": "^8.18.1",
-    "@typescript/native-preview": "7.0.0-dev.20260516.1",
-    "@vitest/snapshot": "^3.2.4",
+    "@typescript/native-preview": "7.0.0-dev.20260608.1",
+    "@vitest/snapshot": "^3.2.6",
     "birpc": "^4.0.0",
     "picomatch": "^4.0.4",
     "playwright": "^1.60.0",
+    "@rstest/core": "0.10.4",
     "@rstest/browser-ui": "0.0.0",
-    "@rstest/tsconfig": "0.0.1",
-    "@rstest/core": "0.10.2"
+    "@rstest/tsconfig": "0.0.1"
   },
   "peerDependencies": {
     "playwright": "^1.49.1",
-    "@rstest/core": "^0.10.2"
+    "@rstest/core": "^0.10.4"
   },
   "peerDependenciesMeta": {
     "playwright": {

package/src/AGENTS.md

@@ -15,6 +15,9 @@ flowchart LR
     SR["sessionRegistry.ts\nRunnerSessionRegistry"]
     WP["watchRerunPlanner.ts"]
     LS["headlessLatestRerunScheduler.ts"]
+    HT["headlessTransport.ts\nattachHeadlessRunnerTransport()"]
+    CC["concurrency.ts\ngetHeadlessConcurrency()"]
+    HQ["headedSerialTaskQueue.ts\ncreateHeadedSerialTaskQueue()"]
   end
 
   subgraph UI["@rstest/browser-ui container (headed path)"]
@@ -35,6 +38,9 @@ flowchart LR
   WP --> LS
   HC --> RL
   RL --> SR
+  HC --> CC
+  HC --> HQ
+  HC --> HT
 
   UR <--> HC
   MSG --> MH
@@ -42,7 +48,7 @@ flowchart LR
   RPC --> CH
   CH --> UR
 
-  HC -."headless bridge:\nexposeFunction(__rstest_dispatch__, __rstest_dispatch_rpc__)".-> Runner
+  HT -."headless bridge:\nexposeFunction(__rstest_dispatch__, __rstest_dispatch_rpc__)".-> Runner
 ```
 
 ## Headed transport path

package/src/client/dispatchTransport.ts

@@ -4,10 +4,15 @@ import type {
 } from '../protocol';
 import {
   DISPATCH_MESSAGE_TYPE,
+  DISPATCH_NAMESPACE_RUNNER,
   DISPATCH_RESPONSE_TYPE,
+  DISPATCH_RPC_BRIDGE_NAME,
   DISPATCH_RPC_REQUEST_TYPE,
 } from '../protocol';
 
+// Coincidentally equal to the host-side RUNNER_FRAMES_READY_TIMEOUT_MS and the
+// runner's CONFIG_WAIT_TIMEOUT_MS (entry.ts), but a semantically distinct
+// default in a different runtime, so deliberately not shared with them.
 const DEFAULT_RPC_TIMEOUT_MS = 30_000;
 
 export const getRpcTimeout = (): number => {
@@ -37,6 +42,63 @@ export const createRequestId = (prefix: string): string => {
   return `${prefix}-${Date.now().toString(36)}-${requestIdCounter.toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
 };
 
+/**
+ * Build a runner-lifecycle dispatch request.
+ *
+ * Lifecycle events (`file-ready`, `suite-start`, `suite-result`, `case-start`)
+ * share the dispatch-rpc envelope but are delivered fire-and-forget via
+ * {@link sendRunnerLifecycle}, so the request id only needs to be unique — it is
+ * produced by the shared {@link createRequestId} factory rather than a bespoke
+ * per-runner counter.
+ */
+export const createRunnerLifecycleRequest = (
+  method: string,
+  args: unknown,
+): BrowserDispatchRequest => ({
+  requestId: createRequestId('runner-lifecycle'),
+  namespace: DISPATCH_NAMESPACE_RUNNER,
+  method,
+  args,
+});
+
+/**
+ * Deliver a runner-lifecycle request fire-and-forget.
+ *
+ * Unlike {@link dispatchRpc}, this never awaits, unwraps, id-matches, or times
+ * out: the host echoes a response but the runner ignores it. Failures surface
+ * only through the optional `onError` hook (debug logging at the call site),
+ * keeping the hot test loop non-blocking.
+ */
+export const sendRunnerLifecycle = (
+  request: BrowserDispatchRequest,
+  onError?: (error: unknown) => void,
+): void => {
+  if (window.parent === window) {
+    const dispatchBridge = window[DISPATCH_RPC_BRIDGE_NAME];
+    if (!dispatchBridge) {
+      onError?.(
+        new Error('Dispatch RPC bridge is not available in top-level runner.'),
+      );
+      return;
+    }
+    void Promise.resolve(dispatchBridge(request)).catch((error: unknown) => {
+      onError?.(error);
+    });
+    return;
+  }
+
+  window.parent.postMessage(
+    {
+      type: DISPATCH_MESSAGE_TYPE,
+      payload: {
+        type: DISPATCH_RPC_REQUEST_TYPE,
+        payload: request,
+      },
+    },
+    '*',
+  );
+};
+
 const isDispatchResponse = (
   value: unknown,
 ): value is BrowserDispatchResponse => {
@@ -116,7 +178,7 @@ export const dispatchRpc = <T>({
   staleMessage: string;
 }): Promise<T> => {
   if (window.parent === window) {
-    const dispatchBridge = window.__rstest_dispatch_rpc__;
+    const dispatchBridge = window[DISPATCH_RPC_BRIDGE_NAME];
     if (!dispatchBridge) {
       throw new Error(
         'Dispatch RPC bridge is not available in top-level runner.',

package/src/client/entry.ts

@@ -12,25 +12,26 @@ import type {
   RunnerHooks,
   RuntimeConfig,
   WorkerState,
-} from '@rstest/core/browser-runtime';
+} from '@rstest/core/internal/browser-runtime';
 import {
   createBrowserTaskContext,
   createRstestRuntime,
   globalApis,
+  RSTEST_ENV_SYMBOL_KEY,
   setRealTimers,
-} from '@rstest/core/browser-runtime';
+  unwrapRegex,
+} from '@rstest/core/internal/browser-runtime';
 import { normalize } from 'pathe';
 import type {
   BrowserClientMessage,
-  BrowserDispatchRequest,
   BrowserProjectRuntime,
+  RunnerLifecycleMethod,
 } from '../protocol';
+import { DISPATCH_MESSAGE_TYPE, RSTEST_CONFIG_MESSAGE_TYPE } from '../protocol';
 import {
-  DISPATCH_MESSAGE_TYPE,
-  DISPATCH_NAMESPACE_RUNNER,
-  DISPATCH_RPC_REQUEST_TYPE,
-  RSTEST_CONFIG_MESSAGE_TYPE,
-} from '../protocol';
+  createRunnerLifecycleRequest,
+  sendRunnerLifecycle,
+} from './dispatchTransport';
 import { BrowserSnapshotEnvironment } from './snapshot';
 import {
   findNewScriptUrl,
@@ -44,14 +45,6 @@ declare global {
   var __coverage__: Record<string, unknown> | undefined;
 }
 
-type RunnerLifecycleMethod =
-  | 'file-ready'
-  | 'suite-start'
-  | 'suite-result'
-  | 'case-start';
-
-let runnerDispatchRequestId = 0;
-
 /**
  * Debug logger for browser client.
  * Only logs when debug mode is enabled (DEBUG=rstest on server side).
@@ -63,27 +56,13 @@ const debugLog = (...args: unknown[]): void => {
 };
 
 type RuntimeEnvStore = Record<string, string | undefined>;
-const RSTEST_ENV_SYMBOL = Symbol.for('rstest.env');
+const RSTEST_ENV_SYMBOL = Symbol.for(RSTEST_ENV_SYMBOL_KEY);
 
 type GlobalWithRuntimeEnv = typeof globalThis &
   Record<symbol, unknown> & {
     global?: typeof globalThis;
   };
 
-const REGEXP_FLAG_PREFIX = 'RSTEST_REGEXP:';
-
-const unwrapRegex = (value: string): string | RegExp => {
-  if (value.startsWith(REGEXP_FLAG_PREFIX)) {
-    const raw = value.slice(REGEXP_FLAG_PREFIX.length);
-    const match = raw.match(/^\/(.+)\/([gimuy]*)$/);
-    if (match) {
-      const [, pattern, flags] = match;
-      return new RegExp(pattern!, flags);
-    }
-  }
-  return value;
-};
-
 const restoreRuntimeConfig = (
   config: BrowserProjectRuntime['runtimeConfig'],
 ): RuntimeConfig => {
@@ -230,42 +209,30 @@ const send = (message: BrowserClientMessage): void => {
   }
   // Fallback: direct call if running outside iframe (not typical)
   // Note: This binding may not exist if not using Playwright
-  window.__rstest_dispatch__?.(message);
+  window[DISPATCH_MESSAGE_TYPE]?.(message);
 };
 
 const dispatchRunnerLifecycle = (
   method: RunnerLifecycleMethod,
   payload: unknown,
 ): void => {
-  const request: BrowserDispatchRequest = {
-    requestId: `runner-lifecycle-${++runnerDispatchRequestId}`,
-    namespace: DISPATCH_NAMESPACE_RUNNER,
-    method,
-    args: payload,
-  };
-
-  if (window.parent === window) {
-    const dispatchBridge = window.__rstest_dispatch_rpc__;
-    if (!dispatchBridge) {
-      debugLog(
-        '[Runner] Missing dispatch bridge for lifecycle method:',
-        method,
-      );
-      return;
-    }
-    void Promise.resolve(dispatchBridge(request)).catch((error: unknown) => {
+  sendRunnerLifecycle(
+    createRunnerLifecycleRequest(method, payload),
+    (error: unknown) => {
       debugLog('[Runner] Failed to dispatch lifecycle method:', method, error);
-    });
-    return;
-  }
-
-  send({
-    type: DISPATCH_RPC_REQUEST_TYPE,
-    payload: request,
-  });
+    },
+  );
 };
 
-/** Timeout for waiting for browser config from container (30 seconds) */
+/**
+ * Timeout for waiting for browser config from container (30 seconds).
+ *
+ * Coincidentally equal to the RPC default (client/dispatchTransport.ts) and the
+ * host's RUNNER_FRAMES_READY_TIMEOUT_MS (hostController.ts), but semantically
+ * distinct and in a different runtime, so deliberately not shared. Implicit
+ * invariant: this must not exceed the host's frames-ready timeout, or the host
+ * declares the runner un-ready before it can even receive its config.
+ */
 const CONFIG_WAIT_TIMEOUT_MS = 30_000;
 
 /**

package/src/client/public.ts

@@ -1,12 +1,12 @@
 /**
- * Re-export runtime API from @rstest/core/browser-runtime for browser use.
+ * Re-export runtime API from @rstest/core/internal/browser-runtime for browser use.
  * This file is used as an alias target for '@rstest/core' in browser mode.
  *
- * Uses @rstest/core/browser-runtime which only exports the test APIs
+ * Uses @rstest/core/internal/browser-runtime which only exports the test APIs
  * (describe, it, expect, etc.) without any Node.js dependencies.
  */
 
 // Re-export types from @rstest/core (these are compile-time only)
 export type { Assertion, Mock } from '@rstest/core';
 // Re-export all public test APIs
-export * from '@rstest/core/browser-runtime';
+export * from '@rstest/core/internal/browser-runtime';

package/src/client/snapshot.ts

@@ -1,4 +1,4 @@
-import type { BrowserDispatchRequest, SnapshotRpcRequest } from '../protocol';
+import type { BrowserDispatchRequest, SnapshotRpcCall } from '../protocol';
 import { DISPATCH_NAMESPACE_SNAPSHOT } from '../protocol';
 import {
   createRequestId,
@@ -11,41 +11,36 @@ const SNAPSHOT_HEADER = '// Rstest Snapshot';
 
 const createSnapshotDispatchRequest = (
   requestId: string,
-  method: SnapshotRpcRequest['method'],
-  args: SnapshotRpcRequest['args'],
+  call: SnapshotRpcCall,
 ): BrowserDispatchRequest => {
   // Snapshot is just one namespace on the shared dispatch RPC channel.
   // Keep this mapping explicit so new runner-side RPC clients can mirror it.
   return {
     requestId,
     namespace: DISPATCH_NAMESPACE_SNAPSHOT,
-    method,
-    args,
+    method: call.method,
+    args: call.args,
   };
 };
 
 /**
  * Send a snapshot RPC request to the container (parent window).
  * The container will forward it to the host via WebSocket RPC.
+ *
+ * `call` is a {@link SnapshotRpcCall}, so `method` and `args` are validated as a
+ * pair — a mismatched argument shape fails to compile at the call site.
  */
-const sendRpcRequest = <T>(
-  method: SnapshotRpcRequest['method'],
-  args: SnapshotRpcRequest['args'],
-): Promise<T> => {
+const sendRpcRequest = <T>(call: SnapshotRpcCall): Promise<T> => {
   const requestId = createRequestId('snapshot-rpc');
   const rpcTimeout = getRpcTimeout();
-  const dispatchRequest = createSnapshotDispatchRequest(
-    requestId,
-    method,
-    args,
-  );
+  const dispatchRequest = createSnapshotDispatchRequest(requestId, call);
 
   return dispatchRpc<T>({
     requestId,
     request: dispatchRequest,
     timeoutMs: rpcTimeout,
     staleMessage: 'Stale snapshot RPC request ignored.',
-    timeoutMessage: `Snapshot RPC timeout after ${rpcTimeout / 1000}s: ${method}`,
+    timeoutMessage: `Snapshot RPC timeout after ${rpcTimeout / 1000}s: ${call.method}`,
   });
 };
 
@@ -67,8 +62,9 @@ export class BrowserSnapshotEnvironment {
   }
 
   async resolvePath(filepath: string): Promise<string> {
-    return sendRpcRequest<string>('resolveSnapshotPath', {
-      testPath: filepath,
+    return sendRpcRequest<string>({
+      method: 'resolveSnapshotPath',
+      args: { testPath: filepath },
     });
   }
 
@@ -77,18 +73,24 @@ export class BrowserSnapshotEnvironment {
   }
 
   async saveSnapshotFile(filepath: string, snapshot: string): Promise<void> {
-    await sendRpcRequest<void>('saveSnapshotFile', {
-      filepath,
-      content: snapshot,
+    await sendRpcRequest<void>({
+      method: 'saveSnapshotFile',
+      args: { filepath, content: snapshot },
     });
   }
 
   async readSnapshotFile(filepath: string): Promise<string | null> {
-    return sendRpcRequest<string | null>('readSnapshotFile', { filepath });
+    return sendRpcRequest<string | null>({
+      method: 'readSnapshotFile',
+      args: { filepath },
+    });
   }
 
   async removeSnapshotFile(filepath: string): Promise<void> {
-    await sendRpcRequest<void>('removeSnapshotFile', { filepath });
+    await sendRpcRequest<void>({
+      method: 'removeSnapshotFile',
+      args: { filepath },
+    });
   }
 
   /**

package/src/client/sourceMapSupport.ts

@@ -102,7 +102,7 @@ export const preloadTestFileSourceMap = async (
  * Preload source map for the runner.js file.
  *
  * This is essential for inline snapshot support because the snapshot code
- * runs in runner.js (which contains @rstest/core/browser-runtime).
+ * runs in runner.js (which contains @rstest/core/internal/browser-runtime).
  * Without this, stack traces from inline snapshots cannot be mapped back
  * to the original source files.
  */