@rstest/browser 0.11.8 → 0.11.9

package/dist/client/protocol.d.ts

@@ -23,6 +23,7 @@ export type BrowserProjectRuntime = {
     name: string;
     environmentName: string;
     projectRoot: string;
+    /** Setup modules are re-evaluated per file, so they cannot share a worker page. */ hasSetupFiles: boolean;
     runtimeConfig: SerializedRuntimeConfig;
     viewport?: BrowserViewport;
 };
@@ -33,7 +34,7 @@ export type BrowserProjectRuntime = {
     testPath: string;
     projectName: string;
 };
-export type FileCleanupDispatchMethod = 'start' | 'end';
+export type FileCleanupDispatchMethod = 'start' | 'end' | 'worker-start' | 'worker-end';
 export type FileCleanupDispatchPayload = {
     projectName: string;
     result?: TestFileResult;
@@ -82,6 +83,7 @@ export type BrowserHostConfig = {
         updateSnapshot: SnapshotUpdateState;
     };
     testFile?: string;
+    /** Test files assigned to one browser worker session. */ testFiles?: string[];
     /**
    * The run identity this document executes under — the runner's SOLE identity
    * source, adopted once at boot and stamped on every outbound message. Headed:

package/dist/client/runner.js

@@ -1,5 +1,5 @@
 import { projectSetupLoaders, projectTestContexts, projects } from "__rstest_virtual_browser_manifest__";
-import { RSTEST_API_GLOBAL_KEY, RSTEST_ENV_SYMBOL_KEY, RSTEST_IMPORT_META_GLOBAL_KEY, SNAPSHOT_HEADER, createBrowserTaskContext, createRstestRuntime, formatConsoleArgs, globalApis, setRealTimers, unwrapRegex } from "@rstest/core/internal/browser-runtime";
+import { FIXTURE_CLEANUP_TIMEOUT_MS, RSTEST_API_GLOBAL_KEY, RSTEST_ENV_SYMBOL_KEY, RSTEST_IMPORT_META_GLOBAL_KEY, SNAPSHOT_HEADER, cleanupWorkerFixtures as browser_runtime_cleanupWorkerFixtures, createBrowserTaskContext, createRstestRuntime, formatConsoleArgs, getRealTimers, globalApis, setRealTimers, unwrapRegex } from "@rstest/core/internal/browser-runtime";
 import { normalize } from "pathe";
 import { AnyMap, TraceMap, encodedMap, originalPositionFor } from "@jridgewell/trace-mapping";
 import convert_source_map from "convert-source-map";
@@ -186,6 +186,42 @@ class BrowserSnapshotEnvironment {
 const debugLog = (...args)=>{
     if (window.__RSTEST_BROWSER_OPTIONS__?.debug) console.log(...args);
 };
+const cloneCoverage = (coverage)=>JSON.parse(JSON.stringify(coverage));
+const subtractCounters = (current, previous)=>Object.fromEntries(Object.entries(current).map(([key, value])=>[
+            key,
+            value - (previous?.[key] ?? 0)
+        ]));
+const getCoverageDelta = (current, previous)=>Object.fromEntries(Object.entries(current).map(([path, file])=>{
+        const previousFile = previous?.[path];
+        return [
+            path,
+            {
+                ...file,
+                s: subtractCounters(file.s, previousFile?.s),
+                f: subtractCounters(file.f, previousFile?.f),
+                b: Object.fromEntries(Object.entries(file.b).map(([key, values])=>[
+                        key,
+                        values.map((value, index)=>value - (previousFile?.b[key]?.[index] ?? 0))
+                    ]))
+            }
+        ];
+    }));
+const cleanupWorkerFixturesWithTimeout = async ()=>{
+    const realTimers = getRealTimers();
+    let timer;
+    try {
+        await Promise.race([
+            browser_runtime_cleanupWorkerFixtures(),
+            new Promise((_, reject)=>{
+                timer = realTimers.setTimeout?.(()=>{
+                    reject(new Error(`Worker fixture cleanup did not finish within ${FIXTURE_CLEANUP_TIMEOUT_MS}ms`));
+                }, FIXTURE_CLEANUP_TIMEOUT_MS);
+            })
+        ]);
+    } finally{
+        if (timer) realTimers.clearTimeout?.(timer);
+    }
+};
 const RSTEST_ENV_SYMBOL = Symbol.for(RSTEST_ENV_SYMBOL_KEY);
 const installRuntimeGlobals = (runtime, runtimeConfig)=>{
     Object.assign(globalThis, {
@@ -289,8 +325,9 @@ const waitForConfig = ()=>{
     if (window.parent === window || window.__RSTEST_BROWSER_OPTIONS__) return Promise.resolve();
     return new Promise((resolve, reject)=>{
         const handleMessage = (event)=>{
-            if (event.data?.type === RSTEST_CONFIG_MESSAGE_TYPE && 'string' == typeof event.data.payload?.runId) {
-                window.__RSTEST_BROWSER_OPTIONS__ = event.data.payload;
+            const payload = event.data?.payload;
+            if (event.data?.type === RSTEST_CONFIG_MESSAGE_TYPE && 'string' == typeof payload?.runId) {
+                window.__RSTEST_BROWSER_OPTIONS__ = payload;
                 debugLog('[Runner] Received config from container:', event.data.payload);
                 window.removeEventListener('message', handleMessage);
                 resolve();
@@ -364,6 +401,9 @@ const run = async ()=>{
     setRealTimers();
     await preloadRunnerSourceMap();
     const targetTestFile = options.testFile;
+    const targetTestFiles = options.testFiles?.length ? options.testFiles : targetTestFile ? [
+        targetTestFile
+    ] : void 0;
     const currentProject = targetTestFile ? findProjectForTestFile(targetTestFile, projects) : projects["0"];
     if (!currentProject) {
         send({
@@ -404,12 +444,7 @@ const run = async ()=>{
         for (const loadSetup of currentSetupLoaders)await loadSetup();
     };
     let testKeysToRun;
-    if (targetTestFile) {
-        const key = toContextKey(targetTestFile, currentProject.projectRoot);
-        testKeysToRun = [
-            key
-        ];
-    } else testKeysToRun = currentTestContext.getTestKeys();
+    testKeysToRun = targetTestFiles ? targetTestFiles.map((testFile)=>toContextKey(testFile, currentProject.projectRoot)) : currentTestContext.getTestKeys();
     const executionMode = options.mode || 'run';
     if ('collect' === executionMode) {
         for (const key of testKeysToRun){
@@ -478,183 +513,269 @@ const run = async ()=>{
     };
     window.addEventListener('error', onWindowError);
     window.addEventListener('unhandledrejection', onUnhandledRejection);
-    for (const key of testKeysToRun){
-        const testPath = toAbsolutePath(key, currentProject.projectRoot);
-        const taskStack = [
-            {
-                taskId: getFileTaskId(testPath),
-                taskType: 'file',
-                testPath
-            }
-        ];
-        const taskContext = createBrowserTaskContext();
-        const shouldInterceptConsole = !runtimeConfig.disableConsoleIntercept || true === runtimeConfig.silent || 'passed-only' === runtimeConfig.silent;
-        const restoreConsole = shouldInterceptConsole ? interceptConsole(projectRuntime.name, ()=>taskContext.getCurrent() ?? taskStack[taskStack.length - 1], runtimeConfig.disableConsoleIntercept ? false : runtimeConfig.printConsoleTrace ?? false) : ()=>{};
-        const workerState = {
-            project: projectRuntime.name,
-            projectRoot: projectRuntime.projectRoot,
-            rootPath: options.rootPath,
-            runtimeConfig,
-            taskId: 0,
-            buildId: 0,
-            outputModule: false,
-            environment: 'browser',
-            currentTask: taskStack[0],
-            testPath,
-            distPath: testPath,
-            snapshotOptions: {
-                updateSnapshot: options.snapshot.updateSnapshot,
-                snapshotEnvironment: new BrowserSnapshotEnvironment(),
-                snapshotFormat: runtimeConfig.snapshotFormat
-            }
-        };
-        const syncCurrentTask = ()=>{
-            workerState.currentTask = taskStack[taskStack.length - 1];
-        };
-        const removeTaskFromStack = (taskId)=>{
-            const taskIndex = taskStack.findLastIndex((task)=>task.taskId === taskId);
-            if (taskIndex < 0) return;
-            taskStack.splice(taskIndex, 1);
-            syncCurrentTask();
-        };
-        const runtime = await createRstestRuntime(workerState, {
-            taskContext
-        });
-        installRuntimeGlobals(runtime, runtimeConfig);
-        let failedTestsCount = 0;
-        const dispatchFileCleanup = async (method, result, waitForAcknowledgement = true)=>{
-            const requestId = createRequestId(`file-cleanup-${method}`);
-            const request = {
-                requestId,
-                namespace: DISPATCH_NAMESPACE_FILE_CLEANUP,
-                method,
-                args: {
-                    projectName: projectRuntime.name,
-                    result,
-                    runId: getRunIdentity(),
+    const keepWorkerFixtures = false === runtimeConfig.isolate && true !== projectRuntime.hasSetupFiles;
+    let restoreWorkerConsole;
+    let workerCleanupFailed = false;
+    let workerCleanupAttempted = false;
+    let setupListeners;
+    let previousIstanbulCoverage;
+    try {
+        for(let fileIndex = 0; fileIndex < testKeysToRun.length; fileIndex++){
+            const key = testKeysToRun[fileIndex];
+            const testPath = toAbsolutePath(key, currentProject.projectRoot);
+            options = {
+                ...options,
+                testFile: testPath
+            };
+            window.__RSTEST_BROWSER_OPTIONS__ = options;
+            const taskStack = [
+                {
+                    taskId: getFileTaskId(testPath),
+                    taskType: 'file',
                     testPath
                 }
+            ];
+            const taskContext = createBrowserTaskContext();
+            const shouldInterceptConsole = !runtimeConfig.disableConsoleIntercept || true === runtimeConfig.silent || 'passed-only' === runtimeConfig.silent;
+            const restoreConsole = shouldInterceptConsole ? interceptConsole(projectRuntime.name, ()=>taskContext.getCurrent() ?? taskStack[taskStack.length - 1], runtimeConfig.disableConsoleIntercept ? false : runtimeConfig.printConsoleTrace ?? false) : ()=>{};
+            if (keepWorkerFixtures) restoreWorkerConsole = restoreConsole;
+            const workerState = {
+                project: projectRuntime.name,
+                projectRoot: projectRuntime.projectRoot,
+                rootPath: options.rootPath,
+                runtimeConfig,
+                taskId: 0,
+                buildId: 0,
+                outputModule: false,
+                environment: 'browser',
+                currentTask: taskStack[0],
+                testPath,
+                distPath: testPath,
+                snapshotOptions: {
+                    updateSnapshot: options.snapshot.updateSnapshot,
+                    snapshotEnvironment: new BrowserSnapshotEnvironment(),
+                    snapshotFormat: runtimeConfig.snapshotFormat
+                }
+            };
+            const syncCurrentTask = ()=>{
+                workerState.currentTask = taskStack[taskStack.length - 1];
+            };
+            const removeTaskFromStack = (taskId)=>{
+                const taskIndex = taskStack.findLastIndex((task)=>task.taskId === taskId);
+                if (taskIndex < 0) return;
+                taskStack.splice(taskIndex, 1);
+                syncCurrentTask();
+            };
+            let runtime;
+            try {
+                runtime = await createRstestRuntime(workerState, {
+                    taskContext
+                });
+                installRuntimeGlobals(runtime, runtimeConfig);
+            } catch (error) {
+                restoreConsole();
+                throw error;
+            }
+            let failedTestsCount = 0;
+            const dispatchFileCleanup = async (method, result, waitForAcknowledgement = true)=>{
+                const requestId = createRequestId(`file-cleanup-${method}`);
+                const request = {
+                    requestId,
+                    namespace: DISPATCH_NAMESPACE_FILE_CLEANUP,
+                    method,
+                    args: {
+                        projectName: projectRuntime.name,
+                        result,
+                        runId: getRunIdentity(),
+                        testPath
+                    }
+                };
+                if (!waitForAcknowledgement) return void sendDispatchRequest(request);
+                await dispatchRpc({
+                    requestId,
+                    request,
+                    timeoutMs: getRpcTimeout('framework'),
+                    timeoutMessage: `File cleanup ${method} acknowledgement timed out for ${testPath}.`,
+                    staleMessage: `File cleanup ${method} became stale for ${testPath}.`
+                });
             };
-            if (!waitForAcknowledgement) return void sendDispatchRequest(request);
-            await dispatchRpc({
-                requestId,
-                request,
-                timeoutMs: getRpcTimeout('framework'),
-                timeoutMessage: `File cleanup ${method} acknowledgement timed out for ${testPath}.`,
-                staleMessage: `File cleanup ${method} became stale for ${testPath}.`
+            const cleanupWorkerFixtures = async (result)=>{
+                await dispatchFileCleanup('worker-start', result);
+                try {
+                    await cleanupWorkerFixturesWithTimeout();
+                } finally{
+                    await dispatchFileCleanup('worker-end');
+                }
+            };
+            const updateIstanbulCoverage = (result)=>{
+                if (!globalThis.__coverage__) return;
+                const currentCoverage = globalThis.__coverage__;
+                result.coverage = getCoverageDelta(currentCoverage, previousIstanbulCoverage);
+                previousIstanbulCoverage = cloneCoverage(currentCoverage);
+            };
+            const runnerHooks = {
+                onFileCleanupStart: async (result)=>{
+                    if (result && globalThis.__coverage__) result.coverage = globalThis.__coverage__;
+                    await dispatchFileCleanup('start', result, window.parent !== window);
+                },
+                onFileCleanupEnd: ()=>dispatchFileCleanup('end', void 0, window.parent !== window),
+                onSnapshotSetupStart: async ()=>{
+                    setRpcPhase('framework');
+                },
+                onSnapshotSetupEnd: async ()=>{
+                    setRpcPhase('test');
+                },
+                onSnapshotFinishStart: async ()=>{
+                    setRpcPhase('framework');
+                },
+                onSnapshotFinishEnd: async ()=>{
+                    setRpcPhase('test');
+                },
+                onTestFileReady: async (test)=>{
+                    dispatchRunnerLifecycle('file-ready', test);
+                },
+                onTestSuiteStart: async (test)=>{
+                    taskStack.push({
+                        taskId: test.testId,
+                        taskName: test.name,
+                        taskParentNames: test.parentNames,
+                        taskType: 'suite',
+                        testPath: test.testPath
+                    });
+                    syncCurrentTask();
+                    dispatchRunnerLifecycle('suite-start', test);
+                },
+                onTestSuiteResult: async (result)=>{
+                    removeTaskFromStack(result.testId);
+                    dispatchRunnerLifecycle('suite-result', result);
+                },
+                onTestCaseStart: async (test)=>{
+                    taskStack.push({
+                        taskId: test.testId,
+                        taskName: test.name,
+                        taskParentNames: test.parentNames,
+                        taskType: 'case',
+                        testPath: test.testPath
+                    });
+                    syncCurrentTask();
+                    dispatchRunnerLifecycle('case-start', test);
+                },
+                onTestCaseResult: async (result)=>{
+                    removeTaskFromStack(result.testId);
+                    if ('fail' === result.status) failedTestsCount++;
+                    send({
+                        type: 'case-result',
+                        payload: result
+                    });
+                },
+                getCountOfFailedTests: async ()=>failedTestsCount
+            };
+            send({
+                type: 'file-start',
+                payload: {
+                    testPath,
+                    projectName: projectRuntime.name
+                }
             });
-        };
-        const runnerHooks = {
-            onFileCleanupStart: async (result)=>{
-                if (result && globalThis.__coverage__) result.coverage = globalThis.__coverage__;
-                await dispatchFileCleanup('start', result, window.parent !== window);
-            },
-            onFileCleanupEnd: ()=>dispatchFileCleanup('end', void 0, window.parent !== window),
-            onSnapshotSetupStart: async ()=>{
-                setRpcPhase('framework');
-            },
-            onSnapshotSetupEnd: async ()=>{
-                setRpcPhase('test');
-            },
-            onSnapshotFinishStart: async ()=>{
+            const unhandledErrors = [];
+            activeUnhandledErrors = unhandledErrors;
+            try {
                 setRpcPhase('framework');
-            },
-            onSnapshotFinishEnd: async ()=>{
-                setRpcPhase('test');
-            },
-            onTestFileReady: async (test)=>{
-                dispatchRunnerLifecycle('file-ready', test);
-            },
-            onTestSuiteStart: async (test)=>{
-                taskStack.push({
-                    taskId: test.testId,
-                    taskName: test.name,
-                    taskParentNames: test.parentNames,
-                    taskType: 'suite',
-                    testPath: test.testPath
-                });
-                syncCurrentTask();
-                dispatchRunnerLifecycle('suite-start', test);
-            },
-            onTestSuiteResult: async (result)=>{
-                removeTaskFromStack(result.testId);
-                dispatchRunnerLifecycle('suite-result', result);
-            },
-            onTestCaseStart: async (test)=>{
-                taskStack.push({
-                    taskId: test.testId,
-                    taskName: test.name,
-                    taskParentNames: test.parentNames,
-                    taskType: 'case',
-                    testPath: test.testPath
+                if (setupListeners) runtime.runner.setRootSuiteListeners(setupListeners);
+                await loadSetupFiles();
+                setupListeners ??= runtime.runner.getRootSuiteListeners();
+                const beforeScripts = getScriptUrls();
+                await currentTestContext.loadTest(key);
+                const afterScripts = getScriptUrls();
+                const chunkUrl = findNewScriptUrl(beforeScripts, afterScripts);
+                if (chunkUrl) await preloadTestFileSourceMap(chunkUrl);
+                const result = await runtime.runner.runTests(testPath, runnerHooks, runtime.api);
+                const cleanupBeforeFileComplete = !keepWorkerFixtures || fileIndex === testKeysToRun.length - 1;
+                if (cleanupBeforeFileComplete) {
+                    workerCleanupAttempted = true;
+                    try {
+                        await cleanupWorkerFixtures(result);
+                    } catch (cleanupError) {
+                        const formattedCleanupError = cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError));
+                        result.status = 'fail';
+                        result.errors = [
+                            ...result.errors ?? [],
+                            {
+                                fullStack: true,
+                                message: `Worker fixture cleanup failed: ${formattedCleanupError.message}`,
+                                name: formattedCleanupError.name,
+                                stack: formattedCleanupError.stack
+                            }
+                        ];
+                    }
+                }
+                updateIstanbulCoverage(result);
+                for(let i = 0; i < 2; i++)await new Promise((resolve)=>{
+                    setTimeout(resolve, 0);
                 });
-                syncCurrentTask();
-                dispatchRunnerLifecycle('case-start', test);
-            },
-            onTestCaseResult: async (result)=>{
-                removeTaskFromStack(result.testId);
-                if ('fail' === result.status) failedTestsCount++;
+                if (unhandledErrors.length > 0) {
+                    result.status = 'fail';
+                    result.errors = [
+                        ...result.errors ?? [],
+                        ...unhandledErrors.map((error)=>({
+                                name: error.name,
+                                message: error.message,
+                                stack: error.stack
+                            }))
+                    ];
+                }
                 send({
-                    type: 'case-result',
+                    type: 'file-complete',
                     payload: result
                 });
-            },
-            getCountOfFailedTests: async ()=>failedTestsCount
-        };
-        send({
-            type: 'file-start',
-            payload: {
-                testPath,
-                projectName: projectRuntime.name
-            }
-        });
-        const unhandledErrors = [];
-        activeUnhandledErrors = unhandledErrors;
-        try {
-            setRpcPhase('framework');
-            await loadSetupFiles();
-            const beforeScripts = getScriptUrls();
-            await currentTestContext.loadTest(key);
-            const afterScripts = getScriptUrls();
-            const chunkUrl = findNewScriptUrl(beforeScripts, afterScripts);
-            if (chunkUrl) await preloadTestFileSourceMap(chunkUrl);
-            const result = await runtime.runner.runTests(testPath, runnerHooks, runtime.api);
-            for(let i = 0; i < 2; i++)await new Promise((resolve)=>{
-                setTimeout(resolve, 0);
-            });
-            if (unhandledErrors.length > 0) {
-                result.status = 'fail';
-                result.errors = [
-                    ...result.errors ?? [],
-                    ...unhandledErrors.map((error)=>({
-                            name: error.name,
-                            message: error.message,
-                            stack: error.stack
-                        }))
-                ];
+            } catch (_error) {
+                let error = _error instanceof Error ? _error : new Error(String(_error));
+                if (!workerCleanupAttempted) try {
+                    workerCleanupAttempted = true;
+                    await cleanupWorkerFixtures();
+                } catch (cleanupError) {
+                    const formattedCleanupError = cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError));
+                    error = new Error(`${error.message}\nWorker fixture cleanup failed: ${formattedCleanupError.message}`, {
+                        cause: error
+                    });
+                }
+                send({
+                    type: 'fatal',
+                    payload: {
+                        message: error.message,
+                        stack: error.stack
+                    }
+                });
+                window.__RSTEST_DONE__ = true;
+                return;
+            } finally{
+                if (keepWorkerFixtures && fileIndex === testKeysToRun.length - 1) restoreWorkerConsole = restoreConsole;
+                else restoreConsole();
+                activeUnhandledErrors = void 0;
             }
-            send({
-                type: 'file-complete',
-                payload: result
-            });
-        } catch (_error) {
-            const error = _error instanceof Error ? _error : new Error(String(_error));
+        }
+    } finally{
+        if (keepWorkerFixtures && !workerCleanupAttempted) try {
+            await cleanupWorkerFixturesWithTimeout();
+        } catch (error) {
+            workerCleanupFailed = true;
+            const cleanupError = error instanceof Error ? error : new Error(String(error));
             send({
                 type: 'fatal',
                 payload: {
-                    message: error.message,
-                    stack: error.stack
+                    message: cleanupError.message,
+                    stack: cleanupError.stack
                 }
             });
-            window.__RSTEST_DONE__ = true;
-            return;
-        } finally{
-            restoreConsole();
-            activeUnhandledErrors = void 0;
         }
+        restoreWorkerConsole?.();
     }
     window.removeEventListener('error', onWindowError);
     window.removeEventListener('unhandledrejection', onUnhandledRejection);
+    if (workerCleanupFailed) {
+        window.__RSTEST_DONE__ = true;
+        return;
+    }
     send({
         type: 'complete'
     });

package/dist/index.js

@@ -1844,11 +1844,6 @@ const ignoredKeyWarnings = {
         isNonDefault: (config)=>'node' !== config.testEnvironment.name,
         message: (config)=>`Ignoring testEnvironment '${config.testEnvironment.name}' in browser mode: the browser itself is the test environment.`
     },
-    isolate: {
-        isNonDefault: (config)=>false === config.isolate,
-        message: ()=>"Ignoring isolate: false in browser mode: each test file still runs in a fresh context.",
-        browserOnly: true
-    },
     detectAsyncLeaks: {
         isNonDefault: (config)=>true === config.detectAsyncLeaks,
         message: ()=>"Ignoring detectAsyncLeaks in browser mode: it relies on node async_hooks."
@@ -1917,6 +1912,8 @@ const reportUnsupportedBrowserOptions = (context)=>{
             }
         }
     }
+    if (isBrowserOnlyRun && browserProjects.some(({ normalizedConfig: config })=>false === config.isolate && false === config.browser.headless)) warnings.add('Browser mode keeps headed file frames isolated, so worker-scoped fixtures do not span files when browser.headless is false.');
+    if (isBrowserOnlyRun && browserProjects.some(({ normalizedConfig: config })=>false === config.isolate && (config.setupFiles?.length ?? 0) > 0)) warnings.add('Browser projects with setupFiles stay file-isolated, even when isolate is false, so setup modules can run for every file.');
     for (const message of warnings)logger.warn(color.yellow(message));
 };
 const validateBrowserConfig = (context)=>{
@@ -2981,9 +2978,7 @@ const createBrowserRuntime = async ({ context, projectEntries: initialProjectEnt
     const refreshProjectEntries = async ()=>{
         validateBrowserConfig(context);
         browserLaunchOptions = ensureConsistentBrowserLaunchOptions(browserProjects);
-        const updatedShardedEntries = freezeShardedEntries ? shardedEntries : context.normalizedConfig.shard ? await resolveShardedEntries(context, {
-            silent: true
-        }) : shardedEntries;
+        const updatedShardedEntries = freezeShardedEntries ? shardedEntries : context.normalizedConfig.shard ? await resolveShardedEntries(context) : shardedEntries;
         projectEntries = await resolveProjectEntries(context, updatedShardedEntries, browserProjects);
         for (const manifestModule of manifestModules)refreshManifestModule(manifestModule);
     };
@@ -4125,26 +4120,25 @@ const createHeadedScheduler = async ({ context, runtime, allTestFiles, hostOptio
     dispatchRouter.register(DISPATCH_NAMESPACE_FILE_CLEANUP, async (request)=>{
         const { runId } = request;
         if (!runId) return;
-        if ('start' === request.method) {
+        if ('start' === request.method || 'worker-start' === request.method) {
             const payload = request.args;
             runs.armCleanupDeadline(runId, FIXTURE_CLEANUP_TIMEOUT_MS, ()=>{
                 (async ()=>{
                     try {
-                        await collectCoverage();
+                        await recoverHeadedContainer();
                         await handleTestFileComplete(createFileCleanupTimeoutResult({
                             message: `File fixture cleanup did not finish within ${FIXTURE_CLEANUP_TIMEOUT_MS}ms`,
                             projectName: payload.projectName,
                             result: payload.result,
                             testPath: payload.testPath
                         }));
-                        await recoverHeadedContainer();
                         runs.resolve(runId);
                     } catch (error) {
                         runs.reject(runId, toError(error));
                     }
                 })();
             });
-        } else if ('end' === request.method) runs.disarmCleanupDeadline(runId);
+        } else if ('end' === request.method || 'worker-end' === request.method) runs.disarmCleanupDeadline(runId);
     });
     const reloadTestFileAndWait = async (file, testNamePattern)=>{
         await startCoverage(file.projectName);
@@ -4462,6 +4456,10 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
             project.name,
             project.projectRoot
         ]));
+    const projectIsolation = new Map(projectRuntimeConfigs.map((project)=>[
+            project.name,
+            project.hasSetupFiles || project.runtimeConfig?.isolate !== false
+        ]));
     const runLifecycle = new RunSessionLifecycle();
     const sessionRegistry = new RunnerSessionRegistry();
     setDispatchPageResolver((target)=>({
@@ -4505,10 +4503,15 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
         const handler = fileCleanupHandlers.get(sessionId);
         if (!handler) return;
         const payload = request.args;
-        if ('start' === request.method) handler.start(payload.result);
-        else if ('end' === request.method) handler.end();
+        if ('start' === request.method) await handler.start(payload);
+        else if ('worker-start' === request.method) await handler.workerStart();
+        else if ('end' === request.method) await handler.end(payload);
+        else if ('worker-end' === request.method) await handler.workerEnd();
     });
-    const dispatchRunnerMessage = async (run, file, sessionId, message)=>{
+    const dispatchRunnerMessage = async (run, files, sessionId, message)=>{
+        const payload = 'payload' in message ? message.payload : void 0;
+        const testPath = payload && 'object' == typeof payload && 'testPath' in payload ? String(payload.testPath) : files[0].testPath;
+        const file = files.find((candidate)=>candidate.testPath === normalize(testPath)) ?? files[0];
         const response = await dispatchRouter.dispatch({
             requestId: nextDispatchRequestId("runner"),
             runToken: run.token,
@@ -4524,8 +4527,10 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
         if (response.stale) return;
         if (response.error) throw new Error(response.error);
     };
-    const runSingleFile = async (run, file, rawCoverage)=>{
+    const runWorkerFiles = async (run, files, rawCoverage)=>{
         if (run.cancelled || runLifecycle.isTokenStale(run.token)) return;
+        const file = files[0];
+        let activeFile = file;
         const viewport = viewportByProject.get(file.projectName);
         const browserContext = await browser.newContext({
             providerOptions: browserLaunchOptions.providerOptions,
@@ -4537,9 +4542,31 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
         let coverageCollection;
         let settled = false;
         let resolveDone = null;
-        let cleanupTimer;
-        let fileCleanupFinished = false;
-        let provisionalResult;
+        let workerCleanupTimer;
+        let dispatchQueue = Promise.resolve();
+        const completedFiles = new Set();
+        const keepWorkerFixtures = false === projectIsolation.get(file.projectName);
+        const fileCleanupStates = new Map();
+        const handleWorkerCleanupTimeout = ()=>{
+            if (settled) return;
+            settled = true;
+            (async ()=>{
+                await closeContextSafely(browserContext);
+                await handleFatal({
+                    message: `Worker fixture cleanup did not finish within ${FIXTURE_CLEANUP_TIMEOUT_MS}ms`
+                });
+                resolveDone?.();
+            })();
+        };
+        const armWorkerCleanupDeadline = ()=>{
+            if (workerCleanupTimer) clearTimeout(workerCleanupTimer);
+            workerCleanupTimer = setTimeout(handleWorkerCleanupTimeout, FIXTURE_CLEANUP_TIMEOUT_MS);
+        };
+        const disarmWorkerCleanupDeadline = ()=>{
+            if (!workerCleanupTimer) return;
+            clearTimeout(workerCleanupTimer);
+            workerCleanupTimer = void 0;
+        };
         const markDone = ()=>{
             if (!settled) {
                 settled = true;
@@ -4560,6 +4587,7 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
             if (!coverageCollection) coverageCollection = (async ()=>{
                 const coverage = await v8Coverage.take(page, projectRootByName.get(file.projectName) ?? context.rootPath, file.projectName);
                 if (coverage) rawCoverage.push(coverage);
+                if (keepWorkerFixtures) await v8Coverage.start(page);
             })();
             await coverageCollection;
         };
@@ -4567,8 +4595,8 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
             page = await browserContext.newPage();
             await v8Coverage?.start(page);
             run.coverageCollectors.add(collectCoverage);
-            page.on('crash', ()=>onPageDead(`Browser page crashed while running ${file.testPath}.`));
-            page.on('close', ()=>onPageDead(`Browser page closed unexpectedly while running ${file.testPath}.`));
+            page.on('crash', ()=>onPageDead(`Browser page crashed while running ${activeFile.testPath}.`));
+            page.on('close', ()=>onPageDead(`Browser page closed unexpectedly while running ${activeFile.testPath}.`));
             const session = sessionRegistry.register({
                 testFile: file.testPath,
                 projectName: file.projectName,
@@ -4578,73 +4606,108 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
                 page
             });
             sessionId = session.id;
-            const clearFileCleanupTimeout = ()=>{
-                if (cleanupTimer) {
-                    clearTimeout(cleanupTimer);
-                    cleanupTimer = void 0;
-                }
-            };
-            const finishFileCleanup = ()=>{
-                fileCleanupFinished = true;
-                clearFileCleanupTimeout();
-            };
             fileCleanupHandlers.set(session.id, {
-                end: finishFileCleanup,
-                start: (result)=>{
-                    if (fileCleanupFinished) return;
-                    provisionalResult = result;
-                    clearFileCleanupTimeout();
-                    cleanupTimer = setTimeout(()=>{
+                workerStart: armWorkerCleanupDeadline,
+                end: (payload)=>{
+                    const state = fileCleanupStates.get(payload.testPath);
+                    if (!state) return;
+                    state.finished = true;
+                    if (state.timer) {
+                        clearTimeout(state.timer);
+                        state.timer = void 0;
+                    }
+                    return collectCoverage().finally(()=>{
+                        coverageCollection = void 0;
+                    });
+                },
+                workerEnd: ()=>{
+                    disarmWorkerCleanupDeadline();
+                    return collectCoverage().finally(()=>{
+                        coverageCollection = void 0;
+                    });
+                },
+                start: async (payload)=>{
+                    const state = fileCleanupStates.get(payload.testPath) ?? {
+                        finished: false
+                    };
+                    if (state.finished) return;
+                    state.result = payload.result;
+                    if (state.timer) clearTimeout(state.timer);
+                    state.timer = setTimeout(()=>{
                         (async ()=>{
                             if (settled) return;
                             settled = true;
                             const message = `File fixture cleanup did not finish within ${FIXTURE_CLEANUP_TIMEOUT_MS}ms`;
                             try {
-                                await collectCoverage();
+                                completedFiles.add(payload.testPath);
                                 await handleTestFileComplete(createFileCleanupTimeoutResult({
                                     message,
                                     projectName: file.projectName,
-                                    result: provisionalResult,
-                                    testPath: file.testPath
+                                    result: state.result,
+                                    testPath: payload.testPath
                                 }));
+                                for (const pendingFile of files)if (!completedFiles.has(pendingFile.testPath)) {
+                                    completedFiles.add(pendingFile.testPath);
+                                    await handleTestFileComplete(createFileCleanupTimeoutResult({
+                                        message: `${message}; file was not run because the previous file cleanup timed out`,
+                                        projectName: pendingFile.projectName,
+                                        testPath: pendingFile.testPath
+                                    }));
+                                }
                             } catch (error) {
                                 const formatted = toError(error);
+                                await closeContextSafely(browserContext);
                                 await handleFatal({
                                     message: formatted.message,
                                     stack: formatted.stack
                                 });
-                                await collectRunCoverage(run);
-                                await cancelRun(run, false);
                             } finally{
                                 resolveDone?.();
                             }
                         })();
                     }, FIXTURE_CLEANUP_TIMEOUT_MS);
+                    fileCleanupStates.set(payload.testPath, state);
                 }
             });
             await attachHeadlessRunnerTransport(page, {
-                onDispatchMessage: async (envelope)=>{
-                    const message = envelope.message;
-                    try {
-                        if (settled) return;
-                        if ('file-complete' === message.type || 'fatal' === message.type) await collectCoverage();
-                        await dispatchRunnerMessage(run, file, session.id, message);
-                        if ('file-complete' === message.type) markDone();
-                        else if ('fatal' === message.type) {
+                onDispatchMessage: (envelope)=>{
+                    const queued = dispatchQueue.then(async ()=>{
+                        try {
+                            const message = envelope.message;
+                            if (settled) return;
+                            if ('file-start' === message.type) {
+                                const startedPath = normalize(message.payload.testPath);
+                                activeFile = files.find((candidate)=>candidate.testPath === startedPath) ?? activeFile;
+                            }
+                            if ('fatal' === message.type) await collectCoverage();
+                            await dispatchRunnerMessage(run, files, session.id, message);
+                            if ('file-complete' === message.type) {
+                                const completedPath = message.payload.testPath;
+                                completedFiles.add(completedPath);
+                            }
+                            if ('complete' !== message.type && ('file-complete' !== message.type || 1 !== files.length || keepWorkerFixtures)) {
+                                if ('fatal' === message.type) {
+                                    markDone();
+                                    await collectRunCoverage(run);
+                                    await cancelRun(run, false);
+                                }
+                            } else {
+                                disarmWorkerCleanupDeadline();
+                                markDone();
+                            }
+                        } catch (error) {
+                            const formatted = toError(error);
+                            await handleFatal({
+                                message: formatted.message,
+                                stack: formatted.stack
+                            });
                             markDone();
                             await collectRunCoverage(run);
                             await cancelRun(run, false);
                         }
-                    } catch (error) {
-                        const formatted = toError(error);
-                        await handleFatal({
-                            message: formatted.message,
-                            stack: formatted.stack
-                        });
-                        markDone();
-                        await collectRunCoverage(run);
-                        await cancelRun(run, false);
-                    }
+                    });
+                    dispatchQueue = queued.catch(()=>{});
+                    return queued;
                 },
                 onDispatchRpc: async (request)=>dispatchRouter.dispatch({
                         ...request,
@@ -4663,6 +4726,7 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
                     updateSnapshot: context.snapshotManager.options.updateSnapshot
                 },
                 testFile: file.testPath,
+                testFiles: files.map((item)=>item.testPath),
                 runId: `${run.token}:${session.id}`
             };
             const serializedOptions = serializeForInlineScript(inlineOptions);
@@ -4703,7 +4767,8 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
                 await cancelRun(run, false);
             }
         } finally{
-            if (cleanupTimer) clearTimeout(cleanupTimer);
+            for (const state of fileCleanupStates.values())if (state.timer) clearTimeout(state.timer);
+            if (workerCleanupTimer) clearTimeout(workerCleanupTimer);
             if (sessionId) fileCleanupHandlers.delete(sessionId);
             run.coverageCollectors.delete(collectCoverage);
             const abandoned = run.cancelled || runLifecycle.isTokenStale(run.token);
@@ -4742,6 +4807,7 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
         ];
         const concurrency = getHeadlessConcurrency(context, queue.length);
         const bail = context.normalizedConfig.bail;
+        const nonIsolatedBatchSize = Math.max(1, bail ? 1 : Math.ceil(files.length / Math.max(concurrency, 1)));
         const worker = async ()=>{
             while(queue.length > 0 && !run.cancelled && runLifecycle.isTokenActive(run.token)){
                 if (bail && context.stateManager.getCountOfFailedTests() >= bail) {
@@ -4754,7 +4820,11 @@ const createHeadlessScheduler = async ({ context, browser, browserLaunchOptions,
                 }
                 const next = queue.shift();
                 if (!next) return;
-                await runSingleFile(run, next, rawCoverage);
+                const batch = [
+                    next
+                ];
+                if (false === projectIsolation.get(next.projectName)) while(batch.length < nonIsolatedBatchSize && queue[0]?.projectName === next.projectName)batch.push(queue.shift());
+                await runWorkerFiles(run, batch, rawCoverage);
             }
         };
         run.done = Promise.all(Array.from({
@@ -5189,6 +5259,7 @@ const runBrowserController = async (context, options)=>{
             name: project.name,
             environmentName: project.environmentName,
             projectRoot: normalize(project.rootPath),
+            hasSetupFiles: (project.normalizedConfig.setupFiles?.length ?? 0) > 0,
             runtimeConfig: serializableConfig(projectRuntimeConfig(project, {
                 envMode: 'static',
                 envOverlay: env
@@ -5584,6 +5655,7 @@ const listBrowserTests = async (context, options)=>{
             name: project.name,
             environmentName: project.environmentName,
             projectRoot: normalize(project.rootPath),
+            hasSetupFiles: (project.normalizedConfig.setupFiles?.length ?? 0) > 0,
             runtimeConfig: serializableConfig(projectRuntimeConfig(project, {
                 envMode: 'static',
                 envOverlay: options?.env

package/dist/protocol.d.ts

@@ -23,6 +23,7 @@ export type BrowserProjectRuntime = {
     name: string;
     environmentName: string;
     projectRoot: string;
+    /** Setup modules are re-evaluated per file, so they cannot share a worker page. */ hasSetupFiles: boolean;
     runtimeConfig: SerializedRuntimeConfig;
     viewport?: BrowserViewport;
 };
@@ -33,7 +34,7 @@ export type BrowserProjectRuntime = {
     testPath: string;
     projectName: string;
 };
-export type FileCleanupDispatchMethod = 'start' | 'end';
+export type FileCleanupDispatchMethod = 'start' | 'end' | 'worker-start' | 'worker-end';
 export type FileCleanupDispatchPayload = {
     projectName: string;
     result?: TestFileResult;
@@ -82,6 +83,7 @@ export type BrowserHostConfig = {
         updateSnapshot: SnapshotUpdateState;
     };
     testFile?: string;
+    /** Test files assigned to one browser worker session. */ testFiles?: string[];
     /**
    * The run identity this document executes under — the runner's SOLE identity
    * source, adopted once at boot and stamped on every outbound message. Headed:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rstest/browser",
-  "version": "0.11.8",
+  "version": "0.11.9",
   "description": "Browser mode support for Rstest testing framework.",
   "keywords": [
     "rstest",
@@ -48,7 +48,7 @@
     "ws": "^8.21.3"
   },
   "devDependencies": {
-    "@rslib/core": "1.0.0-beta.2",
+    "@rslib/core": "1.0.0-beta.3",
     "@types/convert-source-map": "^2.0.3",
     "@types/picomatch": "^4.0.3",
     "@types/ws": "^8.18.1",
@@ -56,13 +56,13 @@
     "birpc": "^4.1.0",
     "picomatch": "^4.0.5",
     "playwright": "^1.62.1",
+    "@rstest/tsconfig": "0.0.1",
     "@rstest/browser-ui": "0.0.0",
-    "@rstest/core": "0.11.8",
-    "@rstest/tsconfig": "0.0.1"
+    "@rstest/core": "0.11.9"
   },
   "peerDependencies": {
     "playwright": "^1.49.1",
-    "@rstest/core": "0.11.8"
+    "@rstest/core": "0.11.9"
   },
   "peerDependenciesMeta": {
     "playwright": {