@rstest/browser 0.9.10 → 0.10.1

package/dist/index.js

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import promises from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { isDeepStrictEqual } from "node:util";
-import { color, createCoverageProvider, getSetupFiles, getTestEntries, isDebug, loadCoverageProvider, logger, rsbuild, serializableConfig } from "@rstest/core/browser";
+import { PhaseTracker, color, createCoverageProvider, getNoTestFilesMessage, getSetupFiles, getTestEntries, isDebug, loadCoverageProvider, logger, resolveProjectBuildCache, 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";
 import sirv from "sirv";
@@ -2800,11 +2800,14 @@ 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__';
+let nextBrowserFilePid = 1000000000;
 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 getFileTaskId = (testPath)=>`file:${testPath}`;
+const getBufferedLogTaskId = (log)=>log.taskId ?? getFileTaskId(log.testPath);
 const createDeferredPromise = ()=>{
     let resolve;
     let reject;
@@ -3059,9 +3062,12 @@ const getAffectedTestFiles = (chunks, entryTestFiles)=>{
     return Array.from(affectedFiles);
 };
 const getRuntimeConfigFromProject = (project)=>{
-    const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate, coverage, snapshotFormat, env, bail, logHeapUsage, chaiConfig, includeTaskLocation } = project.normalizedConfig;
+    const { testNamePattern, testTimeout, passWithNoTests, retry, globals, clearMocks, resetMocks, restoreMocks, unstubEnvs, unstubGlobals, maxConcurrency, printConsoleTrace, disableConsoleIntercept, testEnvironment, hookTimeout, isolate, coverage, snapshotFormat, env, bail, logHeapUsage, detectAsyncLeaks, chaiConfig, includeTaskLocation, silent } = project.normalizedConfig;
     return {
-        env,
+        env: {
+            NODE_ENV: process.env.NODE_ENV,
+            ...env
+        },
         testNamePattern,
         testTimeout,
         hookTimeout,
@@ -3082,8 +3088,10 @@ const getRuntimeConfigFromProject = (project)=>{
         snapshotFormat,
         bail,
         logHeapUsage,
+        detectAsyncLeaks,
         chaiConfig,
-        includeTaskLocation
+        includeTaskLocation,
+        silent
     };
 };
 const getBrowserProjects = (context)=>context.projects.filter((project)=>project.normalizedConfig.browser.enabled);
@@ -3123,7 +3131,8 @@ const collectProjectEntries = async (context)=>{
             includeSource,
             rootPath: context.rootPath,
             projectRoot: project.rootPath,
-            fileFilters: context.fileFilters || []
+            fileFilters: context.fileFilters || [],
+            fileFilterMode: context.fileFilterMode
         });
         const setup = getSetupFiles(setupFiles, project.rootPath);
         return {
@@ -3326,8 +3335,18 @@ const createBrowserRuntime = async ({ context, manifestPath, manifestSource, tem
                         const project = projectByEnvironmentName.get(name);
                         if (!project) return config;
                         const userRsbuildConfig = project.normalizedConfig;
+                        const buildCache = resolveProjectBuildCache({
+                            context,
+                            project
+                        });
                         const setupFiles = Object.values(getSetupFiles(project.normalizedConfig.setupFiles, project.rootPath));
-                        const merged = mergeEnvironmentConfig(config, userRsbuildConfig, {
+                        const merged = mergeEnvironmentConfig(config, {
+                            ...userRsbuildConfig,
+                            performance: buildCache ? {
+                                ...userRsbuildConfig.performance,
+                                buildCache
+                            } : userRsbuildConfig.performance
+                        }, {
                             resolve: {
                                 alias: rstestInternalAliases
                             },
@@ -3572,8 +3591,10 @@ async function resolveProjectEntries(context, shardedEntries) {
     return collectProjectEntries(context);
 }
 const runBrowserController = async (context, options)=>{
-    const { skipOnTestRunEnd = false } = options ?? {};
+    const { skipOnTestRunEnd = false, allowEmptyWatchRun = false, onTraceEvents } = options ?? {};
     const buildStart = Date.now();
+    const isWatchMode = 'watch' === context.command;
+    const phaseTrackers = onTraceEvents ? new Map() : void 0;
     const browserProjects = getBrowserProjects(context);
     const useHeadlessDirect = browserProjects.every((project)=>project.normalizedConfig.browser.headless);
     const browserSourceMapCache = new Map();
@@ -3696,18 +3717,24 @@ const runBrowserController = async (context, options)=>{
     }
     const projectEntries = await resolveProjectEntries(context, options?.shardedEntries);
     const totalTests = projectEntries.reduce((total, item)=>total + item.testFiles.length, 0);
+    const shouldKeepWatchingWithEmptySet = isWatchMode && allowEmptyWatchRun;
     if (0 === totalTests) {
         const code = context.normalizedConfig.passWithNoTests ? 0 : 1;
         if (!skipOnTestRunEnd) {
-            const message = `No test files found, exiting with code ${code}.`;
+            const message = shouldKeepWatchingWithEmptySet ? 'No test files found.' : getNoTestFilesMessage({
+                context,
+                code,
+                defaultMessage: `No test files found, exiting with code ${code}.`
+            });
             if (0 === code) logger.log(color.yellow(message));
             else logger.error(color.red(message));
+            if (context.relatedFilters?.length) logger.log(color.gray('related: '), context.relatedFilters.join(color.gray(', ')));
+            else if (context.fileFilters?.length) logger.log(color.gray('filter: '), context.fileFilters.join(color.gray(', ')));
         }
-        if (0 !== code) ensureProcessExitCode(code);
-        return;
+        if (0 !== code && !shouldKeepWatchingWithEmptySet) ensureProcessExitCode(code);
+        if (!shouldKeepWatchingWithEmptySet) return;
     }
     await notifyTestRunStart();
-    const isWatchMode = 'watch' === context.command;
     const enableCliShortcuts = isWatchMode && isBrowserWatchCliShortcutsEnabled();
     const browserTempOutputRoot = context.normalizedConfig.output.distPath.root;
     const tempDir = isWatchMode && watchContext.runtime ? watchContext.runtime.tempDir : isWatchMode ? join(context.rootPath, browserTempOutputRoot, 'browser', 'watch') : join(context.rootPath, browserTempOutputRoot, 'browser', Date.now().toString());
@@ -3843,26 +3870,57 @@ const runBrowserController = async (context, options)=>{
         }
     };
     const handleTestFileStart = async (payload)=>{
+        if (phaseTrackers) {
+            const tracker = new PhaseTracker({
+                trace: {
+                    testPath: payload.testPath,
+                    project: payload.projectName
+                },
+                pid: nextBrowserFilePid++
+            });
+            tracker.transition('prepare');
+            phaseTrackers.set(payload.testPath, tracker);
+        }
         await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileStart?.({
+                testId: getFileTaskId(payload.testPath),
                 testPath: payload.testPath,
                 tests: []
             })));
     };
     const handleTestFileReady = async (payload)=>{
+        phaseTrackers?.get(payload.testPath)?.transition('tests');
         await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileReady?.(payload)));
     };
     const handleTestSuiteStart = async (payload)=>{
+        phaseTrackers?.get(payload.testPath)?.recordSuiteStart(payload);
         await Promise.all(context.reporters.map((reporter)=>reporter.onTestSuiteStart?.(payload)));
     };
     const handleTestSuiteResult = async (payload)=>{
+        phaseTrackers?.get(payload.testPath)?.recordSuiteResult(payload);
         await Promise.all(context.reporters.map((reporter)=>reporter.onTestSuiteResult?.(payload)));
+        if ('passed-only' === context.normalizedConfig.silent) await flushBufferedLogsForTask({
+            taskId: payload.testId,
+            status: payload.status,
+            taskParentNames: payload.parentNames,
+            taskType: 'suite',
+            testPath: payload.testPath
+        });
     };
     const handleTestCaseStart = async (payload)=>{
+        phaseTrackers?.get(payload.testPath)?.recordCaseStart(payload);
         await Promise.all(context.reporters.map((reporter)=>reporter.onTestCaseStart?.(payload)));
     };
     const handleTestCaseResult = async (payload)=>{
         caseResults.push(payload);
+        phaseTrackers?.get(payload.testPath)?.recordCaseResult(payload);
         await Promise.all(context.reporters.map((reporter)=>reporter.onTestCaseResult?.(payload)));
+        if ('passed-only' === context.normalizedConfig.silent) await flushBufferedLogsForTask({
+            taskId: payload.testId,
+            status: payload.status,
+            taskParentNames: payload.parentNames,
+            taskType: 'case',
+            testPath: payload.testPath
+        });
     };
     const handleTestFileComplete = async (payload)=>{
         reporterResults.push(payload);
@@ -3870,6 +3928,22 @@ const runBrowserController = async (context, options)=>{
             payload
         ], payload.results);
         if (payload.snapshotResult) context.snapshotManager.add(payload.snapshotResult);
+        if (phaseTrackers) {
+            const tracker = phaseTrackers.get(payload.testPath);
+            if (tracker) {
+                tracker.end();
+                const events = tracker.getTraceEvents();
+                if (events) onTraceEvents?.(events);
+                phaseTrackers.delete(payload.testPath);
+            }
+        }
+        if ('passed-only' === context.normalizedConfig.silent) await flushBufferedLogsForTask({
+            taskId: payload.testId,
+            status: payload.status,
+            taskParentNames: payload.parentNames,
+            taskType: 'file',
+            testPath: payload.testPath
+        });
         await Promise.all(context.reporters.map((reporter)=>reporter.onTestFileResult?.(payload)));
         if ('fail' === payload.status) ensureProcessExitCode(1);
     };
@@ -3877,12 +3951,18 @@ const runBrowserController = async (context, options)=>{
         const log = {
             content: payload.content,
             name: payload.level,
+            taskId: payload.taskId,
+            taskName: payload.taskName,
+            taskParentNames: payload.taskParentNames,
+            taskType: payload.taskType,
             testPath: payload.testPath,
             type: payload.type,
             trace: payload.trace
         };
-        const shouldLog = context.normalizedConfig.onConsoleLog?.(log.content) ?? true;
-        if (shouldLog) await Promise.all(context.reporters.map((reporter)=>reporter.onUserConsoleLog?.(log)));
+        if (true === context.normalizedConfig.silent) return;
+        if ('passed-only' === context.normalizedConfig.silent) return void bufferConsoleLog(log);
+        if (context.normalizedConfig.disableConsoleIntercept) return;
+        await emitUserConsoleLog(log);
     };
     const handleFatal = async (payload)=>{
         const error = new Error(payload.message);
@@ -3890,6 +3970,52 @@ const runBrowserController = async (context, options)=>{
         fatalError = error;
         ensureProcessExitCode(1);
     };
+    const bufferedConsoleLogs = new Map();
+    const suiteIdsByChain = new Map();
+    const getSuiteChainKey = (names)=>names.join('\u0000');
+    const pushTaskId = (taskIds, taskId)=>{
+        if (!taskIds.includes(taskId)) taskIds.push(taskId);
+    };
+    const shouldEmitUserConsoleLog = (log)=>context.normalizedConfig.onConsoleLog?.(log.content) !== false;
+    const emitUserConsoleLog = async (log)=>{
+        if (!shouldEmitUserConsoleLog(log)) return;
+        await Promise.all(context.reporters.map((reporter)=>reporter.onUserConsoleLog?.(log)));
+    };
+    const bufferConsoleLog = (log)=>{
+        const taskId = getBufferedLogTaskId(log);
+        const logs = bufferedConsoleLogs.get(taskId) || [];
+        logs.push(log);
+        bufferedConsoleLogs.set(taskId, logs);
+        if ('suite' === log.taskType && log.taskId) suiteIdsByChain.set(getSuiteChainKey([
+            ...log.taskParentNames || [],
+            log.taskName || ''
+        ]), log.taskId);
+    };
+    const flushBufferedLogsForTask = async ({ taskId, status, taskParentNames, taskType, testPath })=>{
+        if ('fail' !== status) return void bufferedConsoleLogs.delete(taskId);
+        const taskIdsToFlush = [];
+        if ('case' === taskType) {
+            pushTaskId(taskIdsToFlush, getFileTaskId(testPath));
+            const suiteNames = taskParentNames || [];
+            for(let i = 0; i < suiteNames.length; i++){
+                const suiteId = suiteIdsByChain.get(getSuiteChainKey(suiteNames.slice(0, i + 1)));
+                if (suiteId) pushTaskId(taskIdsToFlush, suiteId);
+            }
+            pushTaskId(taskIdsToFlush, taskId);
+        }
+        if ('suite' === taskType) {
+            pushTaskId(taskIdsToFlush, getFileTaskId(testPath));
+            pushTaskId(taskIdsToFlush, taskId);
+        }
+        if ('file' === taskType) pushTaskId(taskIdsToFlush, taskId);
+        for (const bufferedTaskId of taskIdsToFlush){
+            const logs = bufferedConsoleLogs.get(bufferedTaskId);
+            if (logs) {
+                bufferedConsoleLogs.delete(bufferedTaskId);
+                for (const log of logs)await Promise.all(context.reporters.map((reporter)=>reporter.onUserConsoleLog?.(log)));
+            }
+        }
+    };
     const runSnapshotRpc = async (request)=>{
         switch(request.method){
             case 'resolveSnapshotPath':
@@ -4148,6 +4274,54 @@ const runBrowserController = async (context, options)=>{
                 logger.debug(`[Headless] Interrupting active run token ${run.token} before scheduling latest rerun`);
             }
         });
+        if (0 === allTestFiles.length) {
+            const duration = {
+                totalTime: buildTime,
+                buildTime,
+                testTime: 0
+            };
+            const result = {
+                results: reporterResults,
+                testResults: caseResults,
+                duration,
+                hasFailure: false,
+                getSourcemap: getBrowserSourcemap,
+                resolveSourcemap: resolveBrowserSourcemap,
+                close: skipOnTestRunEnd ? async ()=>{
+                    sessionRegistry.clear();
+                    await destroyBrowserRuntime(runtime);
+                } : void 0
+            };
+            if (!skipOnTestRunEnd) 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 (0 === rerunPlan.currentTestFiles.length) {
+                            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`));
+                        latestRerunScheduler.enqueueLatest(rerunPlan.currentTestFiles);
+                        return;
+                    }
+                    logBrowserWatchReadyMessage(enableCliShortcuts);
+                };
+                watchContext.hooksEnabled = true;
+                logBrowserWatchReadyMessage(enableCliShortcuts);
+            }
+            return result;
+        }
         const testStart = Date.now();
         await runFilesWithPool(allTestFiles);
         const testTime = Date.now() - testStart;
@@ -4418,18 +4592,21 @@ const runBrowserController = async (context, options)=>{
             if (fatalError) return;
             await reloadTestFileWithTimeout(file, testNamePattern);
         });
-    const testStart = Date.now();
-    try {
-        await waitForRunnerFramesReady(currentTestFiles.map((file)=>file.testPath));
-        for (const file of currentTestFiles){
-            await enqueueHeadedReload(file);
-            if (fatalError) break;
+    let testTime = 0;
+    if (currentTestFiles.length > 0) {
+        const testStart = Date.now();
+        try {
+            await waitForRunnerFramesReady(currentTestFiles.map((file)=>file.testPath));
+            for (const file of currentTestFiles){
+                await enqueueHeadedReload(file);
+                if (fatalError) break;
+            }
+        } catch (error) {
+            fatalError = fatalError ?? toError(error);
+            ensureProcessExitCode(1);
         }
-    } catch (error) {
-        fatalError = fatalError ?? toError(error);
-        ensureProcessExitCode(1);
+        testTime = Date.now() - testStart;
     }
-    const testTime = Date.now() - testStart;
     if (isWatchMode) triggerRerun = async ()=>{
         const newProjectEntries = await collectProjectEntries(context);
         const rerunPlan = planWatchRerun({
@@ -4444,6 +4621,11 @@ const runBrowserController = async (context, options)=>{
             watchContext.lastTestFiles = rerunPlan.currentTestFiles;
             currentTestFiles = rerunPlan.currentTestFiles;
             await rpcManager.notifyTestFileUpdate(currentTestFiles);
+            if (0 === currentTestFiles.length) {
+                logger.log(color.cyan('No browser test files remain after update.\n'));
+                logBrowserWatchReadyMessage(enableCliShortcuts);
+                return;
+            }
             await waitForRunnerFramesReady(currentTestFiles.map((file)=>file.testPath));
         }
         if (rerunPlan.normalizedAffectedTestFiles.length > 0) {

package/dist/protocol.d.ts

@@ -1,8 +1,8 @@
 import type { DevicePreset } from '@rstest/core/browser';
 import type { RuntimeConfig, TestFileResult, TestInfo, TestResult } from '@rstest/core/browser-runtime';
 import type { SnapshotUpdateState } from '@vitest/snapshot';
-export type { BrowserLocatorIR, BrowserRpcRequest, SnapshotRpcRequest, } from './rpcProtocol';
-export { validateBrowserRpcRequest } from './rpcProtocol';
+export type { BrowserLocatorIR, BrowserRpcRequest, 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__";
 export declare const DISPATCH_RPC_BRIDGE_NAME = "__rstest_dispatch_rpc__";
@@ -91,6 +91,10 @@ export type BrowserClientMessage = {
     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;

package/dist/providers/index.d.ts

@@ -1,4 +1,4 @@
-import type { BrowserRpcRequest } from '../rpcProtocol';
+import type { BrowserRpcRequest } from '../rpcProtocol.js';
 /**
  * Browser provider contract hub.
  *

package/dist/providers/playwright/compileLocator.d.ts

@@ -1,3 +1,3 @@
 import type { FrameLocator, Locator, Page } from 'playwright';
-import type { BrowserLocatorIR } from '../../protocol';
+import type { BrowserLocatorIR } from '../../protocol.js';
 export declare const compilePlaywrightLocator: (frame: FrameLocator | Page, locatorIR: BrowserLocatorIR) => Locator;

package/dist/providers/playwright/dispatchBrowserRpc.d.ts

@@ -4,7 +4,7 @@
  * Copyright (c) Microsoft Corporation, Apache-2.0.
  */
 import type { Page } from 'playwright';
-import type { BrowserRpcRequest } from '../../rpcProtocol';
+import type { BrowserRpcRequest } from '../../rpcProtocol.js';
 export declare function dispatchPlaywrightBrowserRpc({ containerPage, runnerPage, request, timeoutFallbackMs, }: {
     containerPage?: Page;
     runnerPage?: Page;

package/dist/providers/playwright/expectUtils.d.ts

@@ -3,7 +3,7 @@
  * https://github.com/microsoft/playwright/blob/main/packages/playwright/src/matchers/matchers.ts
  * Copyright (c) Microsoft Corporation, Apache-2.0.
  */
-import type { BrowserLocatorText } from '../../rpcProtocol';
+import type { BrowserLocatorText } from '../../rpcProtocol.js';
 type ExpectedTextValue = {
     string?: string;
     regexSource?: string;

package/dist/providers/playwright/implementation.d.ts

@@ -1,2 +1,2 @@
-import type { BrowserProviderImplementation } from '../index';
+import type { BrowserProviderImplementation } from '../index.js';
 export declare const playwrightProviderImplementation: BrowserProviderImplementation;

package/dist/providers/playwright/index.d.ts

@@ -1 +1 @@
-export { playwrightProviderImplementation } from './implementation';
+export { playwrightProviderImplementation } from './implementation.js';

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

@@ -1,4 +1,4 @@
-import type { BrowserProviderRuntime } from '../index';
+import type { BrowserProviderRuntime } from '../index.js';
 export declare function launchPlaywrightBrowser({ browserName, headless, providerOptions, }: {
     browserName: 'chromium' | 'firefox' | 'webkit';
     headless: boolean | undefined;

package/dist/providers/playwright/textMatcher.d.ts

@@ -1,8 +1,8 @@
 export declare const reviveBrowserLocatorText: (text: {
-    type: "string";
+    type: 'string';
     value: string;
 } | {
-    type: "regexp";
+    type: 'regexp';
     source: string;
     flags?: string;
 }) => string | RegExp;

package/dist/sessionRegistry.d.ts

@@ -1,4 +1,4 @@
-import type { BrowserProviderContext, BrowserProviderPage } from './providers';
+import type { BrowserProviderContext, BrowserProviderPage } from './providers/index.js';
 type RunnerSessionRecord = {
     id: string;
     testFile: string;

package/dist/viewportPresets.d.ts

@@ -5,7 +5,7 @@
  * `@rstest/core` (`packages/core/src/types/config.ts`) so `defineConfig`
  * autocomplete and runtime validation stay consistent.
  */
-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"];
+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];
 type BrowserViewportSize = {
     width: number;

package/dist/watchRerunPlanner.d.ts

@@ -1,4 +1,4 @@
-import type { TestFileInfo } from './protocol';
+import type { TestFileInfo } from './protocol.js';
 type WatchPlannerProjectEntry = {
     project: {
         name: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rstest/browser",
-  "version": "0.9.10",
+  "version": "0.10.1",
   "description": "Browser mode support for Rstest testing framework.",
   "keywords": [
     "rstest",
@@ -32,7 +32,7 @@
       "default": "./package.json"
     }
   },
-  "main": "./dist/index.js",
+  "main": "./dist/browser.js",
   "files": [
     "dist",
     "src",
@@ -45,25 +45,25 @@
     "open-editor": "^6.0.0",
     "pathe": "^2.0.3",
     "sirv": "^3.0.2",
-    "ws": "^8.20.0"
+    "ws": "^8.20.1"
   },
   "devDependencies": {
-    "@rslib/core": "0.21.3",
+    "@rslib/core": "0.21.5",
     "@types/convert-source-map": "^2.0.3",
     "@types/picomatch": "^4.0.3",
     "@types/ws": "^8.18.1",
-    "@typescript/native-preview": "7.0.0-dev.20260428.1",
+    "@typescript/native-preview": "7.0.0-dev.20260516.1",
     "@vitest/snapshot": "^3.2.4",
     "birpc": "^4.0.0",
     "picomatch": "^4.0.4",
-    "playwright": "^1.59.1",
-    "@rstest/browser-ui": "0.0.0",
+    "playwright": "^1.60.0",
     "@rstest/tsconfig": "0.0.1",
-    "@rstest/core": "0.9.10"
+    "@rstest/browser-ui": "0.0.0",
+    "@rstest/core": "0.10.1"
   },
   "peerDependencies": {
     "playwright": "^1.49.1",
-    "@rstest/core": "^0.9.10"
+    "@rstest/core": "^0.10.1"
   },
   "peerDependenciesMeta": {
     "playwright": {