@rstest/browser 0.11.6 → 0.11.8

package/src/client/entry.ts

@@ -1,807 +0,0 @@
-import {
-  type ManifestProjectConfig,
-  type ManifestTestContext,
-  projectSetupLoaders,
-  // Multi-project APIs
-  projects,
-  projectTestContexts,
-} from '@rstest/browser-manifest';
-import type {
-  CoverageMapData,
-  CurrentTaskInfo,
-  RunnerHooks,
-  RuntimeConfig,
-  WorkerState,
-} from '@rstest/core/internal/browser-runtime';
-import {
-  createBrowserTaskContext,
-  createRstestRuntime,
-  formatConsoleArgs,
-  globalApis,
-  RSTEST_API_GLOBAL_KEY,
-  RSTEST_ENV_SYMBOL_KEY,
-  setRealTimers,
-  unwrapRegex,
-} from '@rstest/core/internal/browser-runtime';
-import { normalize } from 'pathe';
-import type {
-  BrowserClientMessage,
-  BrowserProjectRuntime,
-  RunnerLifecycleMethod,
-} from '../protocol';
-import { DISPATCH_MESSAGE_TYPE, RSTEST_CONFIG_MESSAGE_TYPE } from '../protocol';
-import {
-  createRunnerLifecycleRequest,
-  sendRunnerLifecycle,
-} from './dispatchTransport';
-import { BrowserSnapshotEnvironment } from './snapshot';
-import {
-  findNewScriptUrl,
-  getScriptUrls,
-  preloadRunnerSourceMap,
-  preloadTestFileSourceMap,
-} from './sourceMapSupport';
-
-declare global {
-  // eslint-disable-next-line no-var
-  var __coverage__: Record<string, unknown> | undefined;
-}
-
-/**
- * Debug logger for browser client.
- * Only logs when debug mode is enabled (DEBUG=rstest on server side).
- */
-const debugLog = (...args: unknown[]): void => {
-  if (window.__RSTEST_BROWSER_OPTIONS__?.debug) {
-    console.log(...args);
-  }
-};
-
-type RuntimeEnvStore = Record<string, string | undefined>;
-const RSTEST_ENV_SYMBOL = Symbol.for(RSTEST_ENV_SYMBOL_KEY);
-
-/**
- * Publish the runtime API on the globals test modules read: the
- * `@rstest/core` external and the `import.meta.rstest` define (node parity:
- * `global['@rstest/core']` in runInPool), plus the `globals: true` API names.
- */
-const installRuntimeGlobals = (
-  runtime: Awaited<ReturnType<typeof createRstestRuntime>>,
-  runtimeConfig: RuntimeConfig,
-): void => {
-  (globalThis as Record<string, unknown>)[RSTEST_API_GLOBAL_KEY] = runtime.api;
-  if (runtimeConfig.globals) {
-    for (const apiKey of globalApis) {
-      (globalThis as any)[apiKey] = (runtime.api as any)[apiKey];
-    }
-  }
-};
-
-type GlobalWithRuntimeEnv = typeof globalThis &
-  Record<symbol, unknown> & {
-    global?: typeof globalThis;
-  };
-
-const restoreRuntimeConfig = (
-  config: BrowserProjectRuntime['runtimeConfig'],
-): RuntimeConfig => {
-  const { testNamePattern } = config;
-  // The browser wire (BrowserRuntimeConfig) omits node-only fields
-  // (testEnvironment / coverage / logHeapUsage / detectAsyncLeaks) that the
-  // browser runtime never reads. The shared WorkerState / runner types require
-  // the full RuntimeConfig shape and runner heap sampling is guarded against
-  // the absent logHeapUsage, so widening back here is sound.
-  return {
-    ...config,
-    testNamePattern:
-      typeof testNamePattern === 'string'
-        ? unwrapRegex(testNamePattern)
-        : testNamePattern,
-  } as RuntimeConfig;
-};
-
-const ensureRuntimeEnv = (env: RuntimeConfig['env'] | undefined): void => {
-  const globalRef = globalThis as GlobalWithRuntimeEnv;
-  if (!globalRef.global) {
-    globalRef.global = globalRef;
-  }
-
-  const existingEnv = globalRef[RSTEST_ENV_SYMBOL];
-  let runtimeEnv: RuntimeEnvStore;
-  if (existingEnv && typeof existingEnv === 'object') {
-    runtimeEnv = existingEnv as RuntimeEnvStore;
-  } else {
-    runtimeEnv = {};
-    globalRef[RSTEST_ENV_SYMBOL] = runtimeEnv;
-  }
-
-  if (env) {
-    for (const [key, value] of Object.entries(env)) {
-      const normalizedValue =
-        typeof value === 'string'
-          ? value
-          : value == null
-            ? undefined
-            : String(value);
-
-      if (normalizedValue === undefined) {
-        delete runtimeEnv[key];
-      } else {
-        runtimeEnv[key] = normalizedValue;
-      }
-    }
-  }
-};
-
-const getFileTaskId = (testPath: string): string => {
-  return `file:${testPath}`;
-};
-
-/**
- * Intercept console methods and forward to host via send().
- * Returns a restore function to revert console to original.
- */
-const interceptConsole = (
-  projectName: string,
-  getCurrentTask: () => CurrentTaskInfo | undefined,
-  printConsoleTrace: boolean,
-): (() => void) => {
-  const originalConsole = {
-    log: console.log.bind(console),
-    warn: console.warn.bind(console),
-    error: console.error.bind(console),
-    info: console.info.bind(console),
-    debug: console.debug.bind(console),
-  };
-
-  const getConsoleTrace = (): string | undefined => {
-    if (!printConsoleTrace) return undefined;
-    const stack = new Error('STACK_TRACE').stack;
-    // Skip: Error, getConsoleTrace, createConsoleInterceptor wrapper, console.log call
-    return stack?.split('\n').slice(4).join('\n');
-  };
-
-  const createConsoleInterceptor = (
-    level: 'log' | 'warn' | 'error' | 'info' | 'debug',
-  ) => {
-    return (...args: unknown[]) => {
-      // Call original for browser DevTools
-      originalConsole[level](...args);
-
-      const content = formatConsoleArgs(args);
-      const currentTask = getCurrentTask();
-
-      // Send to host
-      send({
-        type: 'log',
-        payload: {
-          level,
-          content,
-          projectName,
-          taskId: currentTask?.taskId,
-          taskName: currentTask?.taskName,
-          taskParentNames: currentTask?.taskParentNames,
-          taskType: currentTask?.taskType,
-          testPath: currentTask?.testPath ?? '',
-          type: level === 'error' || level === 'warn' ? 'stderr' : 'stdout',
-          trace: getConsoleTrace(),
-        },
-      });
-    };
-  };
-
-  console.log = createConsoleInterceptor('log');
-  console.warn = createConsoleInterceptor('warn');
-  console.error = createConsoleInterceptor('error');
-  console.info = createConsoleInterceptor('info');
-  console.debug = createConsoleInterceptor('debug');
-
-  return () => {
-    console.log = originalConsole.log;
-    console.warn = originalConsole.warn;
-    console.error = originalConsole.error;
-    console.info = originalConsole.info;
-    console.debug = originalConsole.debug;
-  };
-};
-
-const send = (message: BrowserClientMessage): void => {
-  // If in iframe, send to parent window (container) which will forward to host via RPC
-  if (window.parent !== window) {
-    window.parent.postMessage(
-      { type: DISPATCH_MESSAGE_TYPE, payload: message },
-      '*',
-    );
-    return;
-  }
-  // Fallback: direct call if running outside iframe (not typical)
-  // Note: This binding may not exist if not using Playwright
-  window[DISPATCH_MESSAGE_TYPE]?.(message);
-};
-
-const dispatchRunnerLifecycle = (
-  method: RunnerLifecycleMethod,
-  payload: unknown,
-): void => {
-  sendRunnerLifecycle(
-    createRunnerLifecycleRequest(method, payload),
-    (error: unknown) => {
-      debugLog('[Runner] Failed to dispatch lifecycle method:', method, error);
-    },
-  );
-};
-
-/**
- * Timeout for waiting for browser config from container (30 seconds).
- *
- * Coincidentally equal to the RPC default (client/dispatchTransport.ts) and the
- * host's RUNNER_FRAMES_READY_TIMEOUT_MS (hostController.ts), but semantically
- * distinct and in a different runtime, so deliberately not shared. Implicit
- * invariant: this must not exceed the host's frames-ready timeout, or the host
- * declares the runner un-ready before it can even receive its config.
- */
-const CONFIG_WAIT_TIMEOUT_MS = 30_000;
-
-/**
- * Wait for configuration from container if running in iframe.
- * This is a prerequisite for test execution - without config, tests cannot run.
- */
-const waitForConfig = (): Promise<void> => {
-  // If not in iframe or already has config, resolve immediately
-  if (window.parent === window || window.__RSTEST_BROWSER_OPTIONS__) {
-    return Promise.resolve();
-  }
-
-  return new Promise((resolve, reject) => {
-    const handleMessage = (event: MessageEvent) => {
-      if (event.data?.type === RSTEST_CONFIG_MESSAGE_TYPE) {
-        window.__RSTEST_BROWSER_OPTIONS__ = event.data.payload;
-        debugLog(
-          '[Runner] Received config from container:',
-          event.data.payload,
-        );
-        window.removeEventListener('message', handleMessage);
-        resolve();
-      }
-    };
-
-    window.addEventListener('message', handleMessage);
-
-    setTimeout(() => {
-      window.removeEventListener('message', handleMessage);
-      reject(
-        new Error(
-          `[Rstest] Failed to receive browser config within ${CONFIG_WAIT_TIMEOUT_MS / 1000}s. ` +
-            'This may indicate a connection issue between the runner iframe and container.',
-        ),
-      );
-    }, CONFIG_WAIT_TIMEOUT_MS);
-  });
-};
-
-/**
- * Convert absolute path to context key (relative path)
- * e.g., '/project/src/foo.test.ts' -> './src/foo.test.ts'
- *       'D:/project/src/foo.test.ts' -> './src/foo.test.ts'
- *
- * Uses pathe's normalize to handle cross-platform path separators.
- */
-const toContextKey = (absolutePath: string, projectRoot: string): string => {
-  // Normalize both paths to use forward slashes for cross-platform compatibility
-  const normalizedAbsolute = normalize(absolutePath);
-  const normalizedRoot = normalize(projectRoot);
-
-  // Only strip the root at a path boundary: a bare `startsWith` would mangle a
-  // sibling like `/repo/pkg-extra/a.test.ts` under root `/repo/pkg`. Must stay
-  // in sync with the host `toContextKey` (hostController.ts) so the non-watch
-  // import-map keys resolve.
-  const withinRoot =
-    normalizedAbsolute === normalizedRoot ||
-    normalizedAbsolute.startsWith(`${normalizedRoot}/`);
-  if (!withinRoot) {
-    // Test file outside the project root: keep the absolute path as the key so
-    // `toAbsolutePath` round-trips it instead of re-rooting under projectRoot.
-    return normalizedAbsolute;
-  }
-  const relative = normalizedAbsolute.slice(normalizedRoot.length);
-  return relative.startsWith('/') ? `.${relative}` : `./${relative}`;
-};
-
-/**
- * Convert context key to absolute path
- * e.g., './src/foo.test.ts' -> '/project/src/foo.test.ts'
- */
-const toAbsolutePath = (key: string, projectRoot: string): string => {
-  // An absolute key (test file outside the project root, see `toContextKey`)
-  // round-trips as-is; only `./`-prefixed relative keys are re-rooted.
-  if (!key.startsWith('.')) {
-    return key;
-  }
-  // key format: ./src/foo.test.ts
-  // Ensure no double slashes by removing trailing slash from projectRoot
-  const normalizedRoot = normalize(projectRoot).replace(/\/$/, '');
-  return normalizedRoot + key.slice(1);
-};
-
-/**
- * Find the project that contains the given test file.
- * Matches by checking if the testFile path starts with the project root.
- *
- * Uses pathe's normalize to handle cross-platform path separators.
- */
-const findProjectForTestFile = (
-  testFile: string,
-  allProjects: ManifestProjectConfig[],
-): ManifestProjectConfig | undefined => {
-  // Normalize the test file path for cross-platform compatibility
-  const normalizedTestFile = normalize(testFile);
-
-  // Sort projects by root path length (longest first) for most specific match
-  const sorted = [...allProjects].sort(
-    (a, b) => b.projectRoot.length - a.projectRoot.length,
-  );
-
-  for (const proj of sorted) {
-    // projectRoot should already be normalized, but normalize again for safety
-    const normalizedRoot = normalize(proj.projectRoot);
-    if (normalizedTestFile.startsWith(normalizedRoot)) {
-      return proj;
-    }
-  }
-
-  // Fallback to first project
-  return allProjects[0];
-};
-
-const run = async () => {
-  // Wait for configuration if in iframe
-  await waitForConfig();
-  let options = window.__RSTEST_BROWSER_OPTIONS__;
-
-  // Support reading testFile and testNamePattern from URL parameters
-  const urlParams = new URLSearchParams(window.location.search);
-  const urlTestFile = urlParams.get('testFile');
-  const urlRunId = urlParams.get('runId');
-  const urlTestNamePattern = urlParams.get('testNamePattern');
-
-  if (urlTestFile && options) {
-    // Override testFile from URL parameter
-    options = {
-      ...options,
-      testFile: urlTestFile,
-    };
-  }
-
-  if (urlRunId && options) {
-    options = {
-      ...options,
-      runId: urlRunId,
-    };
-  }
-
-  // Override testNamePattern from URL parameter if provided
-  if (urlTestNamePattern && options) {
-    options = {
-      ...options,
-      projects: options.projects.map((project) => ({
-        ...project,
-        runtimeConfig: {
-          ...project.runtimeConfig,
-          testNamePattern: urlTestNamePattern,
-        },
-      })),
-    };
-  }
-
-  if (!options) {
-    send({
-      type: 'fatal',
-      payload: {
-        message: 'Browser test runtime is not configured.',
-      },
-    });
-    window.__RSTEST_DONE__ = true;
-    return;
-  }
-
-  send({ type: 'ready' });
-
-  setRealTimers();
-
-  // Preload runner.js sourcemap for inline snapshot support.
-  // The snapshot code runs in runner.js, so we need its sourcemap
-  // to map stack traces back to original source files.
-  await preloadRunnerSourceMap();
-
-  // Find the project for this test file
-  const targetTestFile = options.testFile;
-  const currentProject = targetTestFile
-    ? findProjectForTestFile(
-        targetTestFile,
-        projects as ManifestProjectConfig[],
-      )
-    : (projects as ManifestProjectConfig[])[0];
-
-  if (!currentProject) {
-    send({
-      type: 'fatal',
-      payload: {
-        message: 'No project found for test file',
-      },
-    });
-    window.__RSTEST_DONE__ = true;
-    return;
-  }
-
-  // Find the runtime config for this project
-  const projectRuntime = options.projects.find(
-    (p) => p.name === currentProject.name,
-  );
-  if (!projectRuntime) {
-    send({
-      type: 'fatal',
-      payload: {
-        message: `Project ${currentProject.name} not found in runtime options`,
-      },
-    });
-    window.__RSTEST_DONE__ = true;
-    return;
-  }
-
-  const runtimeConfig = restoreRuntimeConfig(projectRuntime.runtimeConfig);
-  ensureRuntimeEnv(runtimeConfig.env);
-
-  // Get this project's setup loaders and test context
-  const currentSetupLoaders =
-    (projectSetupLoaders as Record<string, Array<() => Promise<unknown>>>)[
-      currentProject.name
-    ] || [];
-  const currentTestContext = (
-    projectTestContexts as Record<string, ManifestTestContext>
-  )[currentProject.name];
-
-  if (!currentTestContext) {
-    send({
-      type: 'fatal',
-      payload: {
-        message: `Test context not found for project ${currentProject.name}`,
-      },
-    });
-    window.__RSTEST_DONE__ = true;
-    return;
-  }
-
-  const loadSetupFiles = async (): Promise<void> => {
-    for (const loadSetup of currentSetupLoaders) {
-      await loadSetup();
-    }
-  };
-
-  // 1. Determine which test files to run
-  let testKeysToRun: string[];
-
-  if (targetTestFile) {
-    // Single file mode: convert absolute path to context key
-    const key = toContextKey(targetTestFile, currentProject.projectRoot);
-    testKeysToRun = [key];
-  } else {
-    // Full run mode: get all test keys from context
-    testKeysToRun = currentTestContext.getTestKeys();
-  }
-
-  // Check execution mode
-  const executionMode = options.mode || 'run';
-
-  // Collect mode: only gather test metadata without running
-  if (executionMode === 'collect') {
-    for (const key of testKeysToRun) {
-      const testPath = toAbsolutePath(key, currentProject.projectRoot);
-
-      const workerState: WorkerState = {
-        project: projectRuntime.name,
-        projectRoot: projectRuntime.projectRoot,
-        rootPath: options.rootPath,
-        runtimeConfig,
-        taskId: 0,
-        // The kept-module-cache flush keyed on `buildId` is node worker-pool
-        // only (#1373); browser runners never reuse a node worker, so a constant
-        // inert id is correct here.
-        buildId: 0,
-        outputModule: false,
-        environment: 'browser',
-        testPath,
-        distPath: testPath,
-        snapshotOptions: {
-          updateSnapshot: options.snapshot.updateSnapshot,
-          snapshotEnvironment: new BrowserSnapshotEnvironment(),
-          snapshotFormat: runtimeConfig.snapshotFormat,
-        },
-      };
-
-      const runtime = await createRstestRuntime(workerState, {
-        taskContext: createBrowserTaskContext(),
-      });
-
-      installRuntimeGlobals(runtime, runtimeConfig);
-
-      try {
-        // Load setup files for this project after runtime is ready.
-        await loadSetupFiles();
-
-        // Load the test file dynamically (registers tests without running)
-        await currentTestContext.loadTest(key);
-
-        // Collect tests metadata
-        const tests = await runtime.runner.collectTests();
-
-        send({
-          type: 'collect-result',
-          payload: {
-            testPath,
-            project: projectRuntime.name,
-            tests,
-          },
-        });
-      } catch (_error) {
-        const error =
-          _error instanceof Error ? _error : new Error(String(_error));
-        send({
-          type: 'fatal',
-          payload: {
-            message: error.message,
-            stack: error.stack,
-          },
-        });
-        window.__RSTEST_DONE__ = true;
-        return;
-      }
-    }
-
-    send({ type: 'collect-complete' });
-    window.__RSTEST_DONE__ = true;
-    return;
-  }
-
-  // Capture unhandled errors/rejections that escape a test file's execution.
-  // Parity with the node worker, which attaches process-level
-  // uncaughtException/unhandledRejection to the running file's result and fails
-  // the file. `activeUnhandledErrors` points at the currently running file's
-  // collector (undefined between files, so stray late events are ignored).
-  let activeUnhandledErrors: Error[] | undefined;
-  const onWindowError = (event: ErrorEvent): void => {
-    activeUnhandledErrors?.push(
-      event.error instanceof Error
-        ? event.error
-        : new Error(event.message || String(event.error)),
-    );
-  };
-  const onUnhandledRejection = (event: PromiseRejectionEvent): void => {
-    const { reason } = event;
-    activeUnhandledErrors?.push(
-      reason instanceof Error ? reason : new Error(String(reason)),
-    );
-  };
-  window.addEventListener('error', onWindowError);
-  window.addEventListener('unhandledrejection', onUnhandledRejection);
-
-  // 2. Run tests for each file
-  for (const key of testKeysToRun) {
-    const testPath = toAbsolutePath(key, currentProject.projectRoot);
-    const taskStack: CurrentTaskInfo[] = [
-      {
-        taskId: getFileTaskId(testPath),
-        taskType: 'file',
-        testPath,
-      },
-    ];
-
-    // Per-file TaskContext; taskStack supplies the concurrent attribution
-    // that the single-slot fallback can't.
-    const taskContext = createBrowserTaskContext();
-
-    const shouldInterceptConsole =
-      !runtimeConfig.disableConsoleIntercept ||
-      runtimeConfig.silent === true ||
-      runtimeConfig.silent === 'passed-only';
-
-    // Intercept console methods to forward logs to host
-    const restoreConsole = shouldInterceptConsole
-      ? interceptConsole(
-          projectRuntime.name,
-          () => taskContext.getCurrent() ?? taskStack[taskStack.length - 1],
-          runtimeConfig.disableConsoleIntercept
-            ? false
-            : (runtimeConfig.printConsoleTrace ?? false),
-        )
-      : () => {};
-
-    const workerState: WorkerState = {
-      project: projectRuntime.name,
-      projectRoot: projectRuntime.projectRoot,
-      rootPath: options.rootPath,
-      runtimeConfig,
-      taskId: 0,
-      // See the `buildId` note above: inert in browser mode.
-      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 = (): void => {
-      workerState.currentTask = taskStack[taskStack.length - 1];
-    };
-
-    const removeTaskFromStack = (taskId: string): void => {
-      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 runnerHooks: RunnerHooks = {
-      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 (result.status === 'fail') {
-          failedTestsCount++;
-        }
-        send({
-          type: 'case-result',
-          payload: result,
-        });
-      },
-      getCountOfFailedTests: async () => failedTestsCount,
-    };
-
-    send({
-      type: 'file-start',
-      payload: {
-        testPath,
-        projectName: projectRuntime.name,
-      },
-    });
-
-    const unhandledErrors: Error[] = [];
-    activeUnhandledErrors = unhandledErrors;
-
-    try {
-      // Load setup files for this project after runtime is ready.
-      await loadSetupFiles();
-
-      // Record script URLs before loading the test file
-      const beforeScripts = getScriptUrls();
-
-      // Load the test file dynamically using this project's context
-      await currentTestContext.loadTest(key);
-
-      // Find the newly loaded chunk and preload its source map (for inline snapshots)
-      const afterScripts = getScriptUrls();
-      const chunkUrl = findNewScriptUrl(beforeScripts, afterScripts);
-      if (chunkUrl) {
-        await preloadTestFileSourceMap(chunkUrl);
-      }
-
-      const result = await runtime.runner.runTests(
-        testPath,
-        runnerHooks,
-        runtime.api,
-      );
-
-      // The browser dispatches `unhandledrejection` in a task queued at the
-      // current task's microtask checkpoint, so a rejection leaked by a
-      // synchronous test is not observable yet when `runTests()` resolves.
-      // Yield two macrotasks: the first reaches the checkpoint that queues
-      // the event task, the second runs after that task regardless of how
-      // the browser orders the timer and event task sources.
-      for (let i = 0; i < 2; i++) {
-        await new Promise<void>((resolve) => {
-          setTimeout(resolve, 0);
-        });
-      }
-
-      // An unhandled error/rejection that escaped the run fails the file even
-      // when every test passed.
-      if (unhandledErrors.length > 0) {
-        result.status = 'fail';
-        result.errors = [
-          ...(result.errors ?? []),
-          ...unhandledErrors.map((error) => ({
-            name: error.name,
-            message: error.message,
-            stack: error.stack,
-          })),
-        ];
-      }
-
-      // Collect coverage data from global __coverage__ object
-      if (globalThis.__coverage__) {
-        result.coverage = globalThis.__coverage__ as CoverageMapData;
-      }
-
-      send({
-        type: 'file-complete',
-        payload: result,
-      });
-    } catch (_error) {
-      const error =
-        _error instanceof Error ? _error : new Error(String(_error));
-      send({
-        type: 'fatal',
-        payload: {
-          message: error.message,
-          stack: error.stack,
-        },
-      });
-      window.__RSTEST_DONE__ = true;
-      return;
-    } finally {
-      // Restore original console methods
-      restoreConsole();
-      activeUnhandledErrors = undefined;
-    }
-  }
-
-  window.removeEventListener('error', onWindowError);
-  window.removeEventListener('unhandledrejection', onUnhandledRejection);
-
-  send({ type: 'complete' });
-  window.__RSTEST_DONE__ = true;
-};
-
-void run().catch((error) => {
-  const err = error instanceof Error ? error : new Error(String(error));
-  send({
-    type: 'fatal',
-    payload: {
-      message: err.message,
-      stack: err.stack,
-    },
-  });
-  window.__RSTEST_DONE__ = true;
-});