@react-native-harness/jest 1.6.0 → 1.7.0

package/src/resource-lock.ts

@@ -89,6 +89,37 @@ const isMissingFileError = (error: unknown): boolean => {
   );
 };
 
+// On Windows, a file being deleted by another process can briefly fail
+// reads and deletes with EPERM/EBUSY instead of ENOENT.
+const isTransientFsError = (error: unknown): boolean => {
+  return (
+    error instanceof Error &&
+    'code' in error &&
+    (error.code === 'EPERM' || error.code === 'EBUSY')
+  );
+};
+
+const TRANSIENT_FS_RETRIES = 5;
+const TRANSIENT_FS_RETRY_DELAY_MS = 20;
+
+const retryTransientFsError = async <T>(
+  operation: () => Promise<T>,
+): Promise<T> => {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isTransientFsError(error) || attempt >= TRANSIENT_FS_RETRIES) {
+        throw error;
+      }
+
+      await new Promise((resolve) =>
+        setTimeout(resolve, TRANSIENT_FS_RETRY_DELAY_MS),
+      );
+    }
+  }
+};
+
 const isExclusiveCreateError = (error: unknown): boolean => {
   return (
     error instanceof Error &&
@@ -104,7 +135,9 @@ const ensureLockDirectories = async (paths: LockPaths): Promise<void> => {
 
 const readJsonFile = async <T>(filePath: string): Promise<T | null> => {
   try {
-    const content = await fs.readFile(filePath, 'utf8');
+    const content = await retryTransientFsError(() =>
+      fs.readFile(filePath, 'utf8'),
+    );
     return JSON.parse(content) as T;
   } catch (error) {
     if (isMissingFileError(error)) {
@@ -132,7 +165,7 @@ const writeJsonFileAtomic = async <T>(
 
 const removeFileIfPresent = async (filePath: string): Promise<void> => {
   try {
-    await fs.rm(filePath, { force: true });
+    await retryTransientFsError(() => fs.rm(filePath, { force: true }));
   } catch (error) {
     if (!isMissingFileError(error)) {
       throw error;
@@ -338,7 +371,7 @@ export const createResourceLockManager = (
       scopedLogger.debug('queued ticket %s for key %s', ticketId, key);
 
       let heartbeatTimer: NodeJS.Timeout | null = null;
-      let heartbeatInFlight = false;
+      let heartbeatInFlight: Promise<void> | null = null;
       let released = false;
       let didNotifyWait = false;
       const waitStartedAt = Date.now();
@@ -354,6 +387,10 @@ export const createResourceLockManager = (
           heartbeatTimer = null;
         }
 
+        // Let an in-flight refresh finish so it cannot recreate owner.json
+        // after we remove it.
+        await heartbeatInFlight;
+
         const owner = await readJsonFile<ResourceLockMetadata>(
           paths.ownerFilePath,
         );
@@ -366,13 +403,7 @@ export const createResourceLockManager = (
       };
 
       const startHeartbeat = () => {
-        heartbeatTimer = setInterval(async () => {
-          if (heartbeatInFlight) {
-            return;
-          }
-
-          heartbeatInFlight = true;
-
+        const refreshHeartbeat = async () => {
           try {
             const nextHeartbeatAt = Date.now();
             const owner = await readJsonFile<ResourceLockMetadata>(
@@ -383,33 +414,33 @@ export const createResourceLockManager = (
               return;
             }
 
-            const nextMetadata: ResourceLockMetadata = {
+            await writeJsonFileAtomic(paths.ownerFilePath, {
               ...owner,
               heartbeatAt: nextHeartbeatAt,
-            };
-
-            if (released) {
-              return;
-            }
+            });
+            scopedLogger.debug('refreshed heartbeat for ticket %s', ticketId);
+          } catch (error) {
+            // A failed refresh is not fatal by design: the lock goes stale
+            // and another holder reclaims it. Swallow it so a transient
+            // error (e.g. the owner file racing a concurrent release, or an
+            // EPERM on Windows while a file is being deleted) never surfaces
+            // as an unhandled rejection from this interval.
+            scopedLogger.debug(
+              'heartbeat refresh for ticket %s failed: %s',
+              ticketId,
+              error instanceof Error ? error.message : String(error),
+            );
+          }
+        };
 
-            try {
-              await writeJsonFileAtomic(paths.ownerFilePath, nextMetadata);
-              scopedLogger.debug('refreshed heartbeat for ticket %s', ticketId);
-            } catch (error) {
-              // A failed refresh is not fatal by design: the lock goes stale
-              // and another holder reclaims it. Swallow it so a transient
-              // write error (e.g. the owner file racing a concurrent release,
-              // or an EPERM on Windows when the directory is being torn down)
-              // never surfaces as an unhandled rejection from this interval.
-              scopedLogger.debug(
-                'heartbeat refresh for ticket %s failed: %s',
-                ticketId,
-                error instanceof Error ? error.message : String(error),
-              );
-            }
-          } finally {
-            heartbeatInFlight = false;
+        heartbeatTimer = setInterval(() => {
+          if (heartbeatInFlight) {
+            return;
           }
+
+          heartbeatInFlight = refreshHeartbeat().finally(() => {
+            heartbeatInFlight = null;
+          });
         }, heartbeatIntervalMs);
         heartbeatTimer.unref?.();
       };

package/src/run.ts

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import type { Config as JestConfig } from 'jest-runner';
 import { TestResult as JestTestResult } from '@jest/test-result';
 import type {
@@ -9,6 +8,7 @@ import type { HarnessSession } from './harness-session.js';
 import { formatResultsErrors } from 'jest-message-util';
 import { toTestResult } from './toTestResult.js';
 import { formatHarnessErrorMessage } from './format-harness-error.js';
+import { toRelativePosixPath } from './relative-path.js';
 
 // Helper function to flatten nested test suites into a flat array of tests with hierarchy
 const flattenTests = (
@@ -91,14 +91,14 @@ export const runHarnessTestFile: RunHarnessTestFile = async ({
   session,
 }) => {
   const start = Date.now();
-  const relativeTestPath = path.relative(globalConfig.rootDir, testPath);
+  const relativeTestPath = toRelativePosixPath(globalConfig.rootDir, testPath);
 
   // Extract setup files from Jest config and convert to relative paths
   const setupFiles = projectConfig.setupFiles?.map((setupFile) =>
-    path.relative(globalConfig.rootDir, setupFile)
+    toRelativePosixPath(globalConfig.rootDir, setupFile)
   );
   const setupFilesAfterEnv = projectConfig.setupFilesAfterEnv?.map(
-    (setupFile) => path.relative(globalConfig.rootDir, setupFile)
+    (setupFile) => toRelativePosixPath(globalConfig.rootDir, setupFile)
   );
   const testTimeout =
     session.config.testTimeout ??

package/src/watch-session.ts

@@ -0,0 +1,65 @@
+import type { Config } from 'jest-runner';
+import {
+  createHarnessSession,
+  type HarnessSession,
+} from './harness-session.js';
+
+// Jest constructs a new runner (and scheduler) for every watch-mode run, so a
+// per-instance session would leave the previous run's session holding the
+// resource lock while the next run queues behind it. Watch-mode sessions
+// therefore live at module scope and are shared by all runner instances.
+//
+// There is no explicit teardown here: in interactive watch mode Jest exits
+// via process.exit on Ctrl-C / `q`, which does not dispose the session. The
+// lock is reclaimed by the lock manager's pid / stale-owner detection.
+type WatchSessionEntry = {
+  key: string;
+  promise: Promise<HarnessSession>;
+};
+
+let current: WatchSessionEntry | null = null;
+
+// Everything createHarnessSession reads from the Jest config.
+const getSessionKey = (globalConfig: Config.GlobalConfig): string =>
+  JSON.stringify([globalConfig.rootDir, Boolean(globalConfig.collectCoverage)]);
+
+export const getWatchSession = (
+  globalConfig: Config.GlobalConfig
+): Promise<HarnessSession> => {
+  const key = getSessionKey(globalConfig);
+
+  if (current?.key === key) {
+    return current.promise;
+  }
+
+  const stale = current;
+  // The entry is installed synchronously so concurrent callers share it, even
+  // while a stale session is still being disposed.
+  const entry: WatchSessionEntry = {
+    key,
+    promise: (async () => {
+      if (stale) {
+        // A failed disposal must not fail the run.
+        await stale.promise
+          .then((session) => session.dispose())
+          .catch(() => undefined);
+      }
+      return createHarnessSession(globalConfig);
+    })(),
+  };
+  current = entry;
+
+  // Never cache a failed creation; the next run retries.
+  entry.promise.catch(() => {
+    if (current === entry) {
+      current = null;
+    }
+  });
+
+  return entry.promise;
+};
+
+/** @internal Test-only: forget the module-level session without disposing. */
+export const resetWatchSessionForTests = (): void => {
+  current = null;
+};

package/dist/crash-supervisor.d.ts

@@ -1,21 +0,0 @@
-import { type AppMonitor, type HarnessPlatformRunner } from '@react-native-harness/platforms';
-export type CrashSupervisorState = 'idle' | 'launching' | 'ready' | 'running' | 'disposing';
-export type CrashSupervisor = {
-    setActiveTestFile: (testFilePath: string | null) => void;
-    beginLaunch: (testFilePath: string) => void;
-    markReady: () => void;
-    beginTestRun: (testFilePath: string) => void;
-    stop: () => Promise<void>;
-    start: () => Promise<void>;
-    waitForCrash: (testFilePath: string) => Promise<never>;
-    isReady: () => boolean;
-    cancelCrashWaiters: () => void;
-    reset: () => void;
-    dispose: () => Promise<void>;
-};
-export type CrashSupervisorOptions = {
-    appMonitor: AppMonitor;
-    platformRunner: HarnessPlatformRunner;
-};
-export declare const createCrashSupervisor: ({ appMonitor, platformRunner, }: CrashSupervisorOptions) => CrashSupervisor;
-//# sourceMappingURL=crash-supervisor.d.ts.map

package/dist/crash-supervisor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"crash-supervisor.d.ts","sourceRoot":"","sources":["../src/crash-supervisor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAIf,KAAK,qBAAqB,EAC3B,MAAM,iCAAiC,CAAC;AAUzC,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,WAAW,GACX,OAAO,GACP,SAAS,GACT,WAAW,CAAC;AAEhB,MAAM,MAAM,eAAe,GAAG;IAC5B,iBAAiB,EAAE,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACzD,WAAW,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,YAAY,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,YAAY,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;IACvD,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,qBAAqB,CAAC;CACvC,CAAC;AAmCF,eAAO,MAAM,qBAAqB,GAAI,iCAGnC,sBAAsB,KAAG,eAkP3B,CAAC"}

package/dist/crash-supervisor.js

@@ -1,210 +0,0 @@
-import { NativeCrashError, } from './errors.js';
-import { logger } from '@react-native-harness/tools';
-const crashLogger = logger.child('crash');
-const getCrashPhase = (state) => state === 'running' ? 'execution' : 'startup';
-const mergeCrashDetails = (phase, initialDetails, enrichedDetails, fallbackSummary) => ({
-    phase,
-    source: enrichedDetails?.source ?? initialDetails?.source,
-    summary: enrichedDetails?.summary ?? initialDetails?.summary ?? fallbackSummary,
-    signal: enrichedDetails?.signal ?? initialDetails?.signal,
-    exceptionType: enrichedDetails?.exceptionType ?? initialDetails?.exceptionType,
-    processName: enrichedDetails?.processName ?? initialDetails?.processName,
-    pid: enrichedDetails?.pid ?? initialDetails?.pid,
-    stackTrace: enrichedDetails?.stackTrace ?? initialDetails?.stackTrace,
-    rawLines: enrichedDetails?.rawLines ?? initialDetails?.rawLines,
-    artifactType: enrichedDetails?.artifactType ?? initialDetails?.artifactType,
-    artifactPath: enrichedDetails?.artifactPath ?? initialDetails?.artifactPath,
-});
-export const createCrashSupervisor = ({ appMonitor, platformRunner, }) => {
-    let state = 'idle';
-    let activeTestFilePath = null;
-    let crashRejectors = new Set();
-    let disposed = false;
-    let monitoring = true;
-    let isResolvingCrash = false;
-    const getCrashDetailsProvider = () => {
-        if ('getCrashDetails' in appMonitor) {
-            return appMonitor;
-        }
-        if (platformRunner.getCrashDetails) {
-            return platformRunner;
-        }
-        return null;
-    };
-    const rejectCrashWaiters = (testFilePath, details) => {
-        const error = new NativeCrashError(testFilePath, details);
-        for (const reject of crashRejectors) {
-            reject(error);
-        }
-        crashRejectors = new Set();
-    };
-    const handleCrash = async (reason, details) => {
-        if (isResolvingCrash ||
-            (state !== 'launching' && state !== 'running' && state !== 'ready')) {
-            return;
-        }
-        if (!activeTestFilePath) {
-            crashLogger.debug('ignoring crash signal without active test: %s', reason);
-            return;
-        }
-        isResolvingCrash = true;
-        crashLogger.debug('native crash detected during %s (state=%s reason=%s)', activeTestFilePath, state, reason || '(none)');
-        for (const line of details?.rawLines ?? []) {
-            crashLogger.debug('%s', line);
-        }
-        const phase = getCrashPhase(state);
-        const testFilePath = activeTestFilePath;
-        state = 'idle';
-        try {
-            const enrichedDetails = await getCrashDetailsProvider()?.getCrashDetails?.({
-                processName: details?.processName,
-                pid: details?.pid,
-                occurredAt: Date.now(),
-            });
-            const mergedDetails = mergeCrashDetails(phase, details, enrichedDetails, reason);
-            crashLogger.debug('crash details: %o', {
-                phase: mergedDetails.phase,
-                source: mergedDetails.source,
-                summary: mergedDetails.summary,
-                signal: mergedDetails.signal,
-                exceptionType: mergedDetails.exceptionType,
-                processName: mergedDetails.processName,
-                pid: mergedDetails.pid,
-            });
-            rejectCrashWaiters(testFilePath, mergedDetails);
-        }
-        finally {
-            isResolvingCrash = false;
-        }
-    };
-    const confirmCrash = async (reason, details) => {
-        if (disposed || !monitoring || state === 'disposing') {
-            return;
-        }
-        try {
-            const isRunning = await platformRunner.isAppRunning();
-            if (!isRunning) {
-                void handleCrash(reason, details);
-            }
-        }
-        catch (error) {
-            crashLogger.debug('crash confirmation failed', error);
-        }
-    };
-    const appMonitorListener = (event) => {
-        if (disposed || !monitoring) {
-            return;
-        }
-        if (event.type === 'app_started') {
-            return;
-        }
-        if (event.type === 'app_exited') {
-            const details = {
-                source: event.crashDetails?.source ?? event.source,
-                summary: event.crashDetails?.summary,
-                signal: event.crashDetails?.signal,
-                exceptionType: event.crashDetails?.exceptionType,
-                processName: event.crashDetails?.processName,
-                pid: event.crashDetails?.pid ?? event.pid,
-                stackTrace: event.crashDetails?.stackTrace,
-                rawLines: event.crashDetails?.rawLines ??
-                    (event.line ? [event.line] : undefined),
-            };
-            if (event.isConfirmed ?? event.source === 'polling') {
-                void handleCrash('', details);
-            }
-            else {
-                void confirmCrash('', details);
-            }
-            return;
-        }
-        if (event.type === 'possible_crash') {
-            const details = {
-                source: event.crashDetails?.source ?? event.source,
-                summary: event.crashDetails?.summary,
-                signal: event.crashDetails?.signal,
-                exceptionType: event.crashDetails?.exceptionType,
-                processName: event.crashDetails?.processName,
-                pid: event.crashDetails?.pid ?? event.pid,
-                stackTrace: event.crashDetails?.stackTrace,
-                rawLines: event.crashDetails?.rawLines ??
-                    (event.line ? [event.line] : undefined),
-            };
-            if (event.isConfirmed) {
-                void handleCrash(`possible crash signal (${event.source ?? 'unknown'})`, details);
-            }
-            else {
-                void confirmCrash(`possible crash signal (${event.source ?? 'unknown'})`, details);
-            }
-        }
-    };
-    appMonitor.addListener(appMonitorListener);
-    const setActiveTestFile = (testFilePath) => {
-        activeTestFilePath = testFilePath;
-    };
-    const beginLaunch = (testFilePath) => {
-        activeTestFilePath = testFilePath;
-        state = 'launching';
-    };
-    const markReady = () => {
-        if (state !== 'disposing') {
-            state = 'ready';
-        }
-    };
-    const beginTestRun = (testFilePath) => {
-        activeTestFilePath = testFilePath;
-        state = 'running';
-    };
-    const stop = async () => {
-        monitoring = false;
-        await appMonitor.stop();
-    };
-    const start = async () => {
-        monitoring = true;
-        await appMonitor.start();
-    };
-    const waitForCrash = (testFilePath) => new Promise((_, reject) => {
-        if (disposed) {
-            reject(new NativeCrashError(testFilePath, {
-                phase: 'startup',
-                source: 'polling',
-                summary: 'Crash supervisor disposed while waiting for app startup.',
-            }));
-            return;
-        }
-        crashRejectors.add(reject);
-    });
-    const isReady = () => state === 'ready' || state === 'running';
-    const cancelCrashWaiters = () => {
-        crashRejectors = new Set();
-    };
-    const reset = () => {
-        cancelCrashWaiters();
-        isResolvingCrash = false;
-        if (state !== 'disposing') {
-            state = 'idle';
-        }
-    };
-    const dispose = async () => {
-        disposed = true;
-        monitoring = false;
-        state = 'disposing';
-        crashRejectors = new Set();
-        isResolvingCrash = false;
-        appMonitor.removeListener(appMonitorListener);
-        await appMonitor.dispose();
-    };
-    return {
-        setActiveTestFile,
-        beginLaunch,
-        markReady,
-        beginTestRun,
-        stop,
-        start,
-        waitForCrash,
-        isReady,
-        cancelCrashWaiters,
-        reset,
-        dispose,
-    };
-};

package/dist/event-mapper.d.ts

@@ -1,16 +0,0 @@
-import type { TestEvents } from '@jest/test-result';
-import type { Test } from 'jest-runner';
-import type { BridgeEvents } from '@react-native-harness/bridge';
-import type { TestCaseResult } from '@jest/test-result';
-export type EventMapperState = {
-    currentTest?: Test;
-    suiteHierarchy: string[];
-    testResults: Map<string, TestCaseResult>;
-    fileStartTime: number;
-};
-export type HarnessEventMapper = {
-    handleBridgeEvent: (event: BridgeEvents, test: Test) => void;
-    reset: () => void;
-};
-export declare const getHarnessEventMapper: (emit: <T extends keyof TestEvents>(eventName: T, eventData: TestEvents[T]) => void) => HarnessEventMapper;
-//# sourceMappingURL=event-mapper.d.ts.map

package/dist/event-mapper.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"event-mapper.d.ts","sourceRoot":"","sources":["../src/event-mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EASV,YAAY,EACb,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACzC,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,iBAAiB,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;IAC7D,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,MAAM,CAAC,CAAC,SAAS,MAAM,UAAU,EAC/B,SAAS,EAAE,CAAC,EACZ,SAAS,EAAE,UAAU,CAAC,CAAC,CAAC,KACrB,IAAI,KACR,kBA8JF,CAAC"}

package/dist/event-mapper.js

@@ -1,120 +0,0 @@
-export const getHarnessEventMapper = (emit) => {
-    const state = {
-        suiteHierarchy: [],
-        testResults: new Map(),
-        fileStartTime: 0,
-    };
-    const handleBridgeEvent = (event, test) => {
-        // Filter to only process test runner events
-        if (event.type.startsWith('test-') ||
-            event.type.startsWith('suite-') ||
-            event.type.startsWith('file-')) {
-            switch (event.type) {
-                case 'file-started':
-                    handleFileStarted(event, test);
-                    break;
-                case 'file-finished':
-                    handleFileFinished(event, test);
-                    break;
-                case 'suite-started':
-                    handleSuiteStarted(event);
-                    break;
-                case 'suite-finished':
-                    handleSuiteFinished(event);
-                    break;
-                case 'test-started':
-                    handleTestStarted(event, test);
-                    break;
-                case 'test-finished':
-                    handleTestFinished(event, test);
-                    break;
-            }
-        }
-    };
-    const handleFileStarted = (event, test) => {
-        state.currentTest = test;
-        state.fileStartTime = Date.now();
-        state.suiteHierarchy = [];
-        state.testResults.clear();
-        // Don't emit test-file-start here - that should be handled by the Jest runner
-        // when it actually starts running the test file
-    };
-    const handleFileFinished = (_event, _test) => {
-        // File finished - all test results should already be emitted
-        // The final TestResult will be handled by the runHarnessTestFile function
-    };
-    const handleSuiteStarted = (event) => {
-        state.suiteHierarchy.push(event.name);
-    };
-    const handleSuiteFinished = (event) => {
-        // Remove the suite from hierarchy when it finishes
-        const index = state.suiteHierarchy.lastIndexOf(event.name);
-        if (index !== -1) {
-            state.suiteHierarchy.splice(index, 1);
-        }
-    };
-    const handleTestStarted = (event, test) => {
-        const testCaseStartInfo = {
-            ancestorTitles: [...state.suiteHierarchy],
-            fullName: `${state.suiteHierarchy.join(' ')} ${event.name}`.trim(),
-            title: event.name,
-            mode: 'skip', // Default mode, will be updated based on test status
-        };
-        emit('test-case-start', [test.path, testCaseStartInfo]);
-    };
-    const handleTestFinished = (event, test) => {
-        const testCaseResult = {
-            ancestorTitles: [...state.suiteHierarchy],
-            duration: event.duration,
-            failureDetails: [],
-            failureMessages: event.error ? [formatError(event.error)] : [],
-            fullName: `${state.suiteHierarchy.join(' ')} ${event.name}`.trim(),
-            numPassingAsserts: event.status === 'passed' ? 1 : 0,
-            status: mapStatus(event.status),
-            title: event.name,
-            startedAt: Date.now() - event.duration,
-        };
-        state.testResults.set(event.name, testCaseResult);
-        emit('test-case-result', [test.path, testCaseResult]);
-    };
-    const mapStatus = (status) => {
-        return status;
-    };
-    const formatError = (error) => {
-        let errorMessage = `${error.name}: ${error.message}`;
-        if (error.codeFrame) {
-            errorMessage += '\n\n' + formatCodeFrame(error.codeFrame);
-        }
-        return errorMessage;
-    };
-    const formatCodeFrame = (codeFrame) => {
-        const lines = codeFrame.content.split('\n');
-        const lineNumber = codeFrame.location?.row || 1;
-        const column = codeFrame.location?.column || 1;
-        let formatted = `\n${codeFrame.fileName}:${lineNumber}:${column}\n`;
-        // Add context lines around the error
-        const startLine = Math.max(0, lineNumber - 3);
-        const endLine = Math.min(lines.length, lineNumber + 2);
-        for (let i = startLine; i < endLine; i++) {
-            const lineNum = i + 1;
-            const line = lines[i];
-            const isErrorLine = lineNum === lineNumber;
-            formatted += `${lineNum.toString().padStart(3)} | ${line}\n`;
-            if (isErrorLine && column > 0) {
-                const pointer = ' '.repeat(column + 5) + '^';
-                formatted += pointer + '\n';
-            }
-        }
-        return formatted;
-    };
-    const reset = () => {
-        state.suiteHierarchy = [];
-        state.testResults.clear();
-        state.fileStartTime = 0;
-        state.currentTest = undefined;
-    };
-    return {
-        handleBridgeEvent,
-        reset,
-    };
-};

package/dist/global-setup.d.ts

@@ -1,3 +0,0 @@
-import type { Config as JestConfig } from 'jest-runner';
-export default function (globalConfig: JestConfig.GlobalConfig): Promise<void>;
-//# sourceMappingURL=global-setup.d.ts.map

package/dist/global-setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"global-setup.d.ts","sourceRoot":"","sources":["../src/global-setup.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AA4CxD,yBAA+B,YAAY,EAAE,UAAU,CAAC,YAAY,iBA4CnE"}