npm - @rstest/browser - Versions diffs - 0.9.2 → 0.9.3 - Mend

@rstest/browser 0.9.2 → 0.9.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/dist/browser-container/container-static/js/{lib-react.ce60b6aea5.js → lib-react.f905279759.js} RENAMED Viewed

@@ -1,12 +1,12 @@
-/*! LICENSE: lib-react.ce60b6aea5.js.LICENSE.txt */
-/*! LICENSE: lib-react.ce60b6aea5.js.LICENSE.txt */ "use strict";
+/*! LICENSE: lib-react.f905279759.js.LICENSE.txt */
+/*! LICENSE: lib-react.f905279759.js.LICENSE.txt */ "use strict";
 (self.rspackChunk_rstest_browser_ui = self.rspackChunk_rstest_browser_ui || []).push([
     [
         "783"
     ],
     {
         7816 (e, t, n) {
-            var r, l = n(1099), a = n(162), o = n(3085);
+            var r, l = n(1099), a = n(162), o = n(5466);
             function i(e) {
                 var t = "https://react.dev/errors/" + e;
                 if (1 < arguments.length) {
@@ -7947,7 +7947,7 @@
                 }
             })(), e.exports = n(7816);
         },
-        3085 (e, t, n) {
+        5466 (e, t, n) {
             (function e() {
                 if ("u" > typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE) try {
                     __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(e);

package/dist/browser-container/container-static/js/lib-react.f905279759.js.LICENSE.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ /! LICENSE: lib-react.f905279759.js.LICENSE.txt /

package/dist/browser-container/index.html CHANGED Viewed

@@ -12,7 +12,7 @@
     <script>
       window.__RSTEST_BROWSER_OPTIONS__ = __RSTEST_OPTIONS_PLACEHOLDER__;
     </script>
-  <script defer src="/container-static/js/lib-react.ce60b6aea5.js"></script><script defer src="/container-static/js/101.82cdbbe145.js"></script><script defer src="/container-static/js/index.602d6770fe.js"></script><link href="/container-static/css/index.5c72297783.css" rel="stylesheet"></head>
+  <script defer src="/container-static/js/lib-react.f905279759.js"></script><script defer src="/container-static/js/927.514b181bd2.js"></script><script defer src="/container-static/js/index.5acf502b10.js"></script><link href="/container-static/css/index.5c72297783.css" rel="stylesheet"></head>
   <body>
     <div id="root"></div>
   </body>

package/dist/index.js CHANGED Viewed

@@ -2,6 +2,7 @@ import { __webpack_require__ } from "./rslib-runtime.js";
 import { existsSync } from "node:fs";
 import promises from "node:fs/promises";
 import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
 import { TEMP_RSTEST_OUTPUT_DIR, color, getSetupFiles, getTestEntries, isDebug, loadCoverageProvider, logger, rsbuild, serializableConfig } from "@rstest/core/browser";
 import open_editor from "open-editor";
 import { basename, dirname, join, normalize, relative, resolve as external_pathe_resolve } from "pathe";
@@ -2214,27 +2215,42 @@ async function dispatchPlaywrightBrowserRpc({ containerPage, runnerPage, request
     }
     throw new Error(`Unknown browser rpc kind: ${request.kind}`);
 }
-async function launchPlaywrightBrowser({ browserName, headless }) {
+async function launchPlaywrightBrowser({ browserName, headless, providerOptions }) {
     const playwright = await import("playwright");
     const browserType = playwright[browserName];
+    const launchOptions = providerOptions.launch;
+    const launchArgs = Array.isArray(launchOptions?.args) ? launchOptions.args : 'chromium' === browserName ? [
+        '--disable-popup-blocking',
+        '--no-first-run',
+        '--no-default-browser-check'
+    ] : void 0;
     const browser = await browserType.launch({
+        ...launchOptions,
         headless,
-        args: 'chromium' === browserName ? [
-            '--disable-popup-blocking',
-            '--no-first-run',
-            '--no-default-browser-check'
-        ] : void 0
+        args: launchArgs
     });
+    const wrappedBrowser = {
+        close: async ()=>browser.close(),
+        newContext: async ({ providerOptions: contextProviderOptions, viewport })=>{
+            const contextOptions = contextProviderOptions?.context;
+            const context = await browser.newContext({
+                ...contextOptions,
+                viewport
+            });
+            return context;
+        }
+    };
     return {
-        browser: browser
+        browser: wrappedBrowser
     };
 }
 const playwrightProviderImplementation = {
     name: 'playwright',
-    async launchRuntime ({ browserName, headless }) {
+    async launchRuntime ({ browserName, headless, providerOptions }) {
         return launchPlaywrightBrowser({
             browserName,
-            headless
+            headless,
+            providerOptions
         });
     },
     async dispatchRpc ({ containerPage, runnerPage, request, timeoutFallbackMs }) {
@@ -2567,22 +2583,44 @@ const planWatchRerun = ({ projectEntries, previousTestFiles, affectedTestFiles }
     };
 };
 const picomatch = __webpack_require__("../../node_modules/.pnpm/picomatch@4.0.3/node_modules/picomatch/index.js");
+var picomatch_default = /*#__PURE__*/ __webpack_require__.n(picomatch);
 const { createRsbuild: createRsbuild, rspack: rspack } = rsbuild;
 const hostController_dirname = dirname(fileURLToPath(import.meta.url));
 const OPTIONS_PLACEHOLDER = '__RSTEST_OPTIONS_PLACEHOLDER__';
 const serializeForInlineScript = (value)=>JSON.stringify(value).replace(/</g, '\\u003c').replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+const getBrowserProviderOptions = (project)=>{
+    const browserConfig = project.normalizedConfig.browser;
+    return browserConfig.providerOptions ?? {};
+};
+const createDeferredPromise = ()=>{
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej)=>{
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        promise,
+        resolve,
+        reject
+    };
+};
 class ContainerRpcManager {
     wss;
     ws = null;
     rpc = null;
     methods;
-    constructor(wss, methods){
+    onDisconnect;
+    detachActiveSocketListeners = null;
+    constructor(wss, methods, onDisconnect){
         this.wss = wss;
         this.methods = methods;
+        this.onDisconnect = onDisconnect;
         this.setupConnectionHandler();
     }
-    updateMethods(methods) {
+    updateMethods(methods, onDisconnect) {
         this.methods = methods;
+        this.onDisconnect = onDisconnect;
         if (this.ws && this.ws.readyState === this.ws.OPEN) this.attachWebSocket(this.ws);
     }
     setupConnectionHandler() {
@@ -2593,26 +2631,47 @@ class ContainerRpcManager {
         });
     }
     attachWebSocket(ws) {
+        this.detachActiveSocketListeners?.();
+        if (this.rpc && !this.rpc.$closed) this.rpc.$close(new Error('Container RPC transport reattached'));
         this.ws = ws;
+        const messageHandlers = new WeakMap();
         this.rpc = createBirpc(this.methods, {
+            timeout: -1,
             post: (data)=>{
                 if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(data));
             },
             on: (fn)=>{
-                ws.on('message', (message)=>{
+                const handler = (message)=>{
                     try {
                         const data = JSON.parse(message.toString());
                         fn(data);
                     } catch  {}
-                });
+                };
+                messageHandlers.set(fn, handler);
+                ws.on('message', handler);
+            },
+            off: (fn)=>{
+                const handler = messageHandlers.get(fn);
+                if (!handler) return;
+                ws.off('message', handler);
+                messageHandlers.delete(fn);
             }
         });
-        ws.on('close', ()=>{
-            if (this.ws === ws) {
-                this.ws = null;
-                this.rpc = null;
+        const handleClose = ()=>{
+            if (this.ws === ws) this.ws = null;
+            this.detachActiveSocketListeners?.();
+            this.detachActiveSocketListeners = null;
+            if (this.rpc && !this.rpc.$closed) {
+                const disconnectError = new Error('Browser UI WebSocket disconnected before reload completed');
+                this.rpc.$close(disconnectError);
+                this.onDisconnect?.(disconnectError);
             }
-        });
+            this.rpc = null;
+        };
+        ws.on('close', handleClose);
+        this.detachActiveSocketListeners = ()=>{
+            ws.off('close', handleClose);
+        };
     }
     get isConnected() {
         return null !== this.ws && this.ws.readyState === this.ws.OPEN;
@@ -2628,9 +2687,9 @@ class ContainerRpcManager {
     }
     async reloadTestFile(testFile, testNamePattern) {
         logger.debug(`[Browser UI] reloadTestFile called, rpc: ${this.rpc ? 'exists' : 'null'}, ws: ${this.ws ? 'exists' : 'null'}`);
-        if (!this.rpc) return void logger.debug('[Browser UI] RPC not available, skipping reloadTestFile');
+        if (!this.rpc) throw new Error('Browser UI RPC not available for reloadTestFile');
         logger.debug(`[Browser UI] Calling reloadTestFile: ${testFile}`);
-        await this.rpc.reloadTestFile(testFile, testNamePattern);
+        return this.rpc.reloadTestFile(testFile, testNamePattern);
     }
 }
 const watchContext = {
@@ -2701,7 +2760,7 @@ const createBrowserRsbuildDevConfig = (isWatchMode)=>({
         }
     });
 const globToRegexp = (glob)=>{
-    const regex = picomatch.makeRe(glob, {
+    const regex = picomatch_default().makeRe(glob, {
         fastpaths: false,
         noglobstar: false,
         bash: false
@@ -2813,7 +2872,8 @@ const getBrowserLaunchOptions = (project)=>({
         browser: project.normalizedConfig.browser.browser,
         headless: project.normalizedConfig.browser.headless,
         port: project.normalizedConfig.browser.port,
-        strictPort: project.normalizedConfig.browser.strictPort
+        strictPort: project.normalizedConfig.browser.strictPort,
+        providerOptions: getBrowserProviderOptions(project)
     });
 const ensureConsistentBrowserLaunchOptions = (projects)=>{
     if (0 === projects.length) throw new Error('No browser-enabled projects found.');
@@ -2821,7 +2881,7 @@ const ensureConsistentBrowserLaunchOptions = (projects)=>{
     const firstOptions = getBrowserLaunchOptions(firstProject);
     for (const project of projects.slice(1)){
         const options = getBrowserLaunchOptions(project);
-        if (options.provider !== firstOptions.provider || options.browser !== firstOptions.browser || options.headless !== firstOptions.headless || options.port !== firstOptions.port || options.strictPort !== firstOptions.strictPort) throw new Error(`Browser launch config mismatch between projects "${firstProject.name}" and "${project.name}". All browser-enabled projects in one run must share provider/browser/headless/port/strictPort.`);
+        if (options.provider !== firstOptions.provider || options.browser !== firstOptions.browser || options.headless !== firstOptions.headless || options.port !== firstOptions.port || options.strictPort !== firstOptions.strictPort || !isDeepStrictEqual(options.providerOptions, firstOptions.providerOptions)) throw new Error(`Browser launch config mismatch between projects "${firstProject.name}" and "${project.name}". All browser-enabled projects in one run must share provider/browser/headless/port/strictPort/providerOptions.`);
     }
     return firstOptions;
 };
@@ -3241,12 +3301,14 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
         const providerImplementation = getBrowserProviderImplementation(browserLaunchOptions.provider);
         const runtime = await providerImplementation.launchRuntime({
             browserName,
-            headless: forceHeadless ?? browserLaunchOptions.headless
+            headless: forceHeadless ?? browserLaunchOptions.headless,
+            providerOptions: browserLaunchOptions.providerOptions
         });
         return {
             rsbuildInstance,
             devServer,
             browser: runtime.browser,
+            browserLaunchOptions,
             port,
             wsPort,
             manifestPath,
@@ -3445,7 +3507,7 @@ const runBrowserController = async (context, options)=>{
             });
         }
     }
-    const { browser, port, wsPort, wss } = runtime;
+    const { browser, browserLaunchOptions, port, wsPort, wss } = runtime;
     const buildTime = Date.now() - buildStart;
     const allTestFiles = projectEntries.flatMap((entry)=>entry.testFiles.map((testPath)=>({
                 testPath: normalize(testPath),
@@ -3665,6 +3727,7 @@ const runBrowserController = async (context, options)=>{
             if (run.cancelled || runLifecycle.isTokenStale(run.token)) return;
             const viewport = viewportByProject.get(file.projectName);
             const browserContext = await browser.newContext({
+                providerOptions: browserLaunchOptions.providerOptions,
                 viewport: viewport ?? null
             });
             run.contexts.add(browserContext);
@@ -3970,6 +4033,7 @@ const runBrowserController = async (context, options)=>{
     } else {
         isNewPage = true;
         containerContext = await browser.newContext({
+            providerOptions: browserLaunchOptions.providerOptions,
             viewport: null
         });
         containerPage = await containerContext.newPage();
@@ -3991,21 +4055,61 @@ const runBrowserController = async (context, options)=>{
     activeContainerPage = containerPage;
     const dispatchRouter = createDispatchRouter();
     const headedReloadQueue = createHeadedSerialTaskQueue();
+    const pendingHeadedReloads = new Map();
     let enqueueHeadedReload = async (_file, _testNamePattern)=>{
         throw new Error('Headed reload queue is not initialized');
     };
+    const rejectPendingHeadedReload = (testPath, error, runId)=>{
+        const pending = pendingHeadedReloads.get(testPath);
+        if (!pending) return;
+        if (runId && pending.runId !== runId) return;
+        pendingHeadedReloads.delete(testPath);
+        pending.deferred.reject(error);
+    };
+    const rejectAllPendingHeadedReloads = (error)=>{
+        for (const [testPath, pending] of pendingHeadedReloads){
+            pendingHeadedReloads.delete(testPath);
+            pending.deferred.reject(error);
+        }
+    };
+    const registerPendingHeadedReload = (testPath, runId)=>{
+        const previousPending = pendingHeadedReloads.get(testPath);
+        if (previousPending) {
+            previousPending.deferred.reject(new Error(`Reload for "${testPath}" was superseded by a newer request.`));
+            pendingHeadedReloads.delete(testPath);
+        }
+        const deferred = createDeferredPromise();
+        pendingHeadedReloads.set(testPath, {
+            runId,
+            deferred
+        });
+        return deferred.promise;
+    };
+    const resolvePendingHeadedReload = (testPath, runId)=>{
+        const pending = pendingHeadedReloads.get(testPath);
+        if (!pending) return;
+        if (runId && pending.runId !== runId) return void logger.debug(`[Browser UI] Ignoring stale file-complete for ${testPath}. current=${pending.runId}, incoming=${runId}`);
+        pendingHeadedReloads.delete(testPath);
+        pending.deferred.resolve();
+    };
     const reloadTestFileWithTimeout = async (file, testNamePattern)=>{
         const timeoutMs = getHeadedPerFileTimeoutMs(file);
         let timeoutId;
+        let reloadAck;
         try {
+            reloadAck = await rpcManager.reloadTestFile(file.testPath, testNamePattern);
+            const completionPromise = registerPendingHeadedReload(file.testPath, reloadAck.runId);
             await Promise.race([
-                rpcManager.reloadTestFile(file.testPath, testNamePattern),
+                completionPromise,
                 new Promise((_, reject)=>{
                     timeoutId = setTimeout(()=>{
                         reject(new Error(`Headed test execution timeout after ${timeoutMs / 1000}s for ${file.testPath}.`));
                     }, timeoutMs);
                 })
             ]);
+        } catch (error) {
+            if (reloadAck?.runId) rejectPendingHeadedReload(file.testPath, toError(error), reloadAck.runId);
+            throw error;
         } finally{
             if (timeoutId) clearTimeout(timeoutId);
         }
@@ -4031,12 +4135,21 @@ const runBrowserController = async (context, options)=>{
                 await handleTestCaseResult(payload);
             },
             async onTestFileComplete (payload) {
-                await handleTestFileComplete(payload);
+                try {
+                    await handleTestFileComplete(payload);
+                    resolvePendingHeadedReload(payload.testPath, payload.runId);
+                } catch (error) {
+                    rejectPendingHeadedReload(payload.testPath, toError(error), payload.runId);
+                    throw error;
+                }
             },
             async onLog (payload) {
                 await handleLog(payload);
             },
             async onFatal (payload) {
+                const error = new Error(payload.message);
+                error.stack = payload.stack;
+                rejectAllPendingHeadedReloads(error);
                 await handleFatal(payload);
             },
             async dispatch (request) {
@@ -4046,11 +4159,11 @@ const runBrowserController = async (context, options)=>{
     let rpcManager;
     if (isWatchMode && runtime.rpcManager) {
         rpcManager = runtime.rpcManager;
-        rpcManager.updateMethods(createRpcMethods());
+        rpcManager.updateMethods(createRpcMethods(), rejectAllPendingHeadedReloads);
         const existingWs = rpcManager.currentWebSocket;
         if (existingWs) rpcManager.reattach(existingWs);
     } else {
-        rpcManager = new ContainerRpcManager(wss, createRpcMethods());
+        rpcManager = new ContainerRpcManager(wss, createRpcMethods(), rejectAllPendingHeadedReloads);
         if (isWatchMode) runtime.rpcManager = rpcManager;
     }
     if (isNewPage) {
@@ -4200,7 +4313,7 @@ const listBrowserTests = async (context, options)=>{
         logger.error(color.red(`Failed to initialize browser provider runtime (${providers.join(', ')}).`), error);
         throw error;
     }
-    const { browser, port } = runtime;
+    const { browser, browserLaunchOptions, port } = runtime;
     const projectRuntimeConfigs = browserProjects.map((project)=>({
             name: project.name,
             environmentName: project.environmentName,
@@ -4228,6 +4341,7 @@ const listBrowserTests = async (context, options)=>{
         resolveCollect = resolve;
     });
     const browserContext = await browser.newContext({
+        providerOptions: browserLaunchOptions.providerOptions,
         viewport: null
     });
     const page = await browserContext.newPage();
@@ -4341,6 +4455,7 @@ const validateBrowserConfig = (context)=>{
             if (!browser.provider) throw new Error('browser.provider is required when browser.enabled is true.');
             if (!SUPPORTED_PROVIDERS.includes(browser.provider)) throw new Error(`browser.provider must be one of: ${SUPPORTED_PROVIDERS.join(', ')}.`);
             validateViewport(browser.viewport);
+            if (!isPlainObject(browser.providerOptions)) throw new Error('browser.providerOptions must be a plain object.');
         }
     }
 };

package/dist/providers/index.d.ts CHANGED Viewed

@@ -4,6 +4,14 @@ import type { BrowserRpcRequest } from '../rpcProtocol';
  *
  * When adding a new built-in provider, implement `BrowserProviderImplementation`
  * and register it in `providerImplementations` below.
+ *
+ * Provider-agnostic policy:
+ * - keep shared contracts and behavior provider-neutral
+ * - `browser.providerOptions` stays opaque at the framework boundary
+ * - do not export provider-owned config types from `@rstest/browser`
+ * - 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
  */
 export type BrowserProvider = 'playwright';
 /** Minimal console shape needed by host logging bridge. */
@@ -46,6 +54,7 @@ export type BrowserProviderBrowser = {
             width: number;
             height: number;
         } | null;
+        providerOptions?: Record<string, unknown>;
     }) => Promise<BrowserProviderContext>;
 };
 /** Provider launch result consumed by hostController. */
@@ -56,6 +65,7 @@ export type BrowserProviderRuntime = {
 export type LaunchBrowserInput = {
     browserName: 'chromium' | 'firefox' | 'webkit';
     headless: boolean | undefined;
+    providerOptions: Record<string, unknown>;
 };
 /** Input contract for provider-side browser RPC dispatch. */
 export type DispatchBrowserRpcInput = {

package/dist/providers/playwright/runtime.d.ts CHANGED Viewed

@@ -1,5 +1,6 @@
 import type { BrowserProviderRuntime } from '../index';
-export declare function launchPlaywrightBrowser({ browserName, headless, }: {
+export declare function launchPlaywrightBrowser({ browserName, headless, providerOptions, }: {
     browserName: 'chromium' | 'firefox' | 'webkit';
     headless: boolean | undefined;
+    providerOptions: Record<string, unknown>;
 }): Promise<BrowserProviderRuntime>;

package/dist/rslib-runtime.js CHANGED Viewed

@@ -10,9 +10,29 @@ function __webpack_require__(moduleId) {
     return module.exports;
 }
 __webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__.add = function(modules) {
         Object.assign(__webpack_require__.m, modules);
     };
 })();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
 export { __webpack_require__ };

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@rstest/browser",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Browser mode support for Rstest testing framework.",
   "bugs": {
     "url": "https://github.com/web-infra-dev/rstest/issues"
@@ -52,18 +52,19 @@
     "@types/convert-source-map": "^2.0.3",
     "@types/picomatch": "^4.0.2",
     "@types/ws": "^8.18.1",
+    "@typescript/native-preview": "7.0.0-dev.20260317.1",
     "@vitest/snapshot": "^3.2.4",
     "birpc": "^4.0.0",
     "picocolors": "^1.1.1",
     "picomatch": "^4.0.3",
     "playwright": "^1.58.2",
-    "@rstest/core": "0.9.2",
+    "@rstest/core": "0.9.3",
     "@rstest/tsconfig": "0.0.1",
     "@rstest/browser-ui": "0.0.0"
   },
   "peerDependencies": {
     "playwright": "^1.49.1",
-    "@rstest/core": "^0.9.2"
+    "@rstest/core": "^0.9.3"
   },
   "peerDependenciesMeta": {
     "playwright": {

package/src/AGENTS.md CHANGED Viewed

@@ -42,7 +42,7 @@ flowchart LR
   RPC --> CH
   CH --> UR
-  HC -."headless bridge:\nexposeFunction(\_\_rstest_dispatch\_\_, \_\_rstest_dispatch_rpc\_\_)".-> Runner
+  HC -."headless bridge:\nexposeFunction(__rstest_dispatch__, __rstest_dispatch_rpc__)".-> Runner
 ```
 ## Headed transport path

package/src/client/AGENTS.md CHANGED Viewed

@@ -6,7 +6,7 @@ This document is architecture-only and focuses on the browser runner runtime in
 ```mermaid
 flowchart TD
-  A["waitForConfig()"] --> B["read \_\_RSTEST_BROWSER_OPTIONS\_\_ + URL overrides"]
+  A["waitForConfig()"] --> B["read __RSTEST_BROWSER_OPTIONS__ + URL overrides"]
   B --> R["send ready"]
   R --> C["setRealTimers()"]
   C --> D["preloadRunnerSourceMap()"]
@@ -23,7 +23,7 @@ flowchart TD
   L --> N["send file-complete per file"]
   N --> O["send complete after all files"]
-  H --> M["window.\_\_RSTEST_DONE\_\_ = true"]
+  H --> M["window.__RSTEST_DONE__ = true"]
   O --> M
 ```
@@ -32,19 +32,19 @@ flowchart TD
 ```mermaid
 flowchart LR
   subgraph IframePath["Iframe path (headed)"]
-    S1["send()"] --> P1["parent.postMessage(\_\_rstest_dispatch\_\_)"]
+    S1["send()"] --> P1["parent.postMessage(__rstest_dispatch__)"]
     R1["dispatchRunnerLifecycle()"] --> P2["postMessage dispatch-rpc-request"]
-    SN1["snapshot.sendRpcRequest()"] --> P3["postMessage dispatch-rpc-request + wait \_\_rstest_dispatch_response\_\_"]
+    SN1["snapshot.sendRpcRequest()"] --> P3["postMessage dispatch-rpc-request + wait __rstest_dispatch_response__"]
   end
   subgraph TopLevelRunPath["Top-level page path (headless run)"]
-    S2["send()"] --> D1["window.\_\_rstest_dispatch\_\_"]
-    R2["dispatchRunnerLifecycle()"] --> D2["window.\_\_rstest_dispatch_rpc\_\_"]
-    SN2["snapshot.sendRpcRequest()"] --> D3["window.\_\_rstest_dispatch_rpc\_\_"]
+    S2["send()"] --> D1["window.__rstest_dispatch__"]
+    R2["dispatchRunnerLifecycle()"] --> D2["window.__rstest_dispatch_rpc__"]
+    SN2["snapshot.sendRpcRequest()"] --> D3["window.__rstest_dispatch_rpc__"]
   end
   subgraph TopLevelCollectPath["Top-level page path (list collect)"]
-    S3["send()"] --> C1["window.\_\_rstest_dispatch\_\_"]
+    S3["send()"] --> C1["window.__rstest_dispatch__"]
   end
 ```

package/src/configValidation.ts CHANGED Viewed

@@ -62,5 +62,9 @@ export const validateBrowserConfig = (context: Rstest): void => {
     }
     validateViewport(browser.viewport);
+    if (!isPlainObject(browser.providerOptions)) {
+      throw new Error('browser.providerOptions must be a plain object.');
+    }
   }
 };