@react-native-harness/jest 1.1.0 → 1.2.0

package/dist/__tests__/index.test.js

@@ -1,42 +1,99 @@
-import { describe, expect, it, vi } from 'vitest';
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { HarnessError } from '@react-native-harness/tools';
 import JestHarness from '../index.js';
-import { StartupStallError } from '../errors.js';
+const resolveUndefined = async () => undefined;
+// ---------------------------------------------------------------------------
+// Module mocks
+// ---------------------------------------------------------------------------
+const mockSession = {
+    config: { metroPort: 8081 },
+    context: {},
+    ensureAppReady: vi.fn(resolveUndefined),
+    runTestFile: vi.fn(async () => ({
+        name: '',
+        tests: [],
+        suites: [],
+        status: 'passed',
+        duration: 0,
+    })),
+    restartApp: vi.fn(resolveUndefined),
+    resetCrashState: vi.fn(),
+    flushClientLogs: vi.fn(() => []),
+    callHook: vi.fn(resolveUndefined),
+    setRunState: vi.fn(),
+    dispose: vi.fn(resolveUndefined),
+};
+const mockCreateHarnessSession = vi.hoisted(() => vi.fn(async () => mockSession));
+const mockExecuteRun = vi.hoisted(() => vi.fn(async () => undefined));
+vi.mock('../harness-session.js', () => ({
+    createHarnessSession: mockCreateHarnessSession,
+}));
+vi.mock('../execute-run.js', () => ({
+    executeRun: mockExecuteRun,
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const makeOptions = () => ({ serial: true });
+const makeWatcher = () => ({ isInterrupted: () => false });
+const makeTest = () => ({
+    path: '/test/example.ts',
+    context: { config: {} },
+});
+const makeGlobalConfig = (overrides = {}) => ({ rootDir: '/project', watch: false, watchAll: false, collectCoverage: false, ...overrides });
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+beforeEach(() => {
+    vi.clearAllMocks();
+    mockSession.dispose.mockResolvedValue(undefined);
+    mockExecuteRun.mockResolvedValue(undefined);
+    mockCreateHarnessSession.mockResolvedValue(mockSession);
+});
 describe('JestHarness', () => {
-    it('reports StartupStallError without a stack trace', async () => {
-        const runner = new JestHarness({});
-        const onFailure = vi.fn();
-        const harness = {
-            ensureAppReady: vi
-                .fn()
-                .mockRejectedValue(new StartupStallError(1500, 3)),
-            callHook: vi.fn(async () => undefined),
-            setRunState: vi.fn(),
-            getRunState: vi.fn(() => null),
-            crashSupervisor: {
-                beginTestRun: vi.fn(),
-                waitForCrash: vi.fn(),
-                cancelCrashWaiters: vi.fn(),
-                reset: vi.fn(),
-            },
-        };
-        await runner._createInBandTestRun([
-            {
-                path: '/tmp/example.harness.ts',
-                context: {
-                    config: {},
-                },
-            },
-        ], {
-            isInterrupted: () => false,
-        }, harness, {
-            detectNativeCrashes: true,
-            resetEnvironmentBetweenTestFiles: false,
-        }, () => Promise.resolve(), () => Promise.resolve(), onFailure);
-        expect(onFailure).toHaveBeenCalledWith(expect.objectContaining({
-            path: '/tmp/example.harness.ts',
-        }), {
-            message: 'The app did not request its Metro bundle after 3 launch attempts within 1500ms. Last Metro status: unknown.',
-            stack: '',
+    describe('session lifecycle', () => {
+        it('creates a session on the first run', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
+        });
+        it('reuses the session across runs in watch mode', async () => {
+            const runner = new JestHarness(makeGlobalConfig({ watch: true }));
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
+            expect(mockSession.dispose).not.toHaveBeenCalled();
+        });
+        it('disposes the session after each run in normal mode', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            expect(mockSession.dispose).toHaveBeenCalledOnce();
+        });
+        it('creates a fresh session for each run in normal mode', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+            expect(mockCreateHarnessSession).toHaveBeenCalledTimes(2);
+        });
+    });
+    describe('error handling', () => {
+        it('converts HarnessError into a formatted string before throwing', async () => {
+            class TestHarnessError extends HarnessError {
+                constructor() { super('something went wrong'); this.name = 'TestHarnessError'; }
+            }
+            mockCreateHarnessSession.mockRejectedValue(new TestHarnessError());
+            const runner = new JestHarness(makeGlobalConfig());
+            await expect(runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions())).rejects.toBeTypeOf('string');
+        });
+        it('propagates non-HarnessError exceptions as-is', async () => {
+            const cause = new TypeError('unexpected');
+            mockCreateHarnessSession.mockRejectedValue(cause);
+            const runner = new JestHarness(makeGlobalConfig());
+            await expect(runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions())).rejects.toBe(cause);
+        });
+        it('throws when called without serial flag', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            await expect(runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), { serial: false })).rejects.toThrow('Parallel test running is not supported');
         });
     });
 });

package/dist/__tests__/resource-lock.test.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { createResourceLockManager, hashResourceLockKey, } from '../resource-lock.js';
+import { createResourceLockManager } from '../resource-lock.js';
 describe('resource lock manager', () => {
     let rootDir;
     beforeEach(async () => {
@@ -54,10 +54,11 @@ describe('resource lock manager', () => {
         await expect(acquirePromise).rejects.toMatchObject({
             name: 'AbortError',
         });
-        const queueDir = path.join(rootDir, hashResourceLockKey(key), 'queue');
-        const queuedEntries = await fs.readdir(queueDir);
-        expect(queuedEntries).toHaveLength(0);
+        // The aborted waiter must have cleaned up its ticket. Verify by releasing
+        // the first lock and confirming a fresh acquire completes immediately.
         await firstLease.release();
+        const cleanupLease = await manager.acquire(key);
+        await cleanupLease.release();
     });
     it('keeps queued tickets alive while the waiting process is still active', async () => {
         const manager = createResourceLockManager({
@@ -76,29 +77,27 @@ describe('resource lock manager', () => {
         await secondLease.release();
     });
     it('reclaims a stale owner before granting the lock', async () => {
-        const manager = createResourceLockManager({
+        const key = 'web:browser:chromium';
+        // Simulate a live process holding the lock.
+        const manager1 = createResourceLockManager({
+            rootDir,
+            pollIntervalMs: 5,
+            heartbeatIntervalMs: 20,
+        });
+        const staleLease = await manager1.acquire(key);
+        // A second manager whose isProcessActive always returns false will consider
+        // any owner — including the live one above — immediately stale and reclaim it.
+        const manager2 = createResourceLockManager({
             rootDir,
             pollIntervalMs: 5,
             heartbeatIntervalMs: 20,
             staleLockTimeoutMs: 50,
             isProcessActive: () => false,
         });
-        const key = 'web:browser:chromium';
-        const keyDir = path.join(rootDir, hashResourceLockKey(key));
-        const queueDir = path.join(keyDir, 'queue');
-        const ownerFilePath = path.join(keyDir, 'owner.json');
-        await fs.mkdir(queueDir, { recursive: true });
-        await fs.writeFile(ownerFilePath, JSON.stringify({
-            ticketId: 'stale-owner',
-            key,
-            pid: 999999,
-            createdAt: Date.now() - 1000,
-            heartbeatAt: Date.now() - 1000,
-        }), 'utf8');
-        const lease = await manager.acquire(key);
-        const owner = JSON.parse(await fs.readFile(ownerFilePath, 'utf8'));
-        expect(owner.ticketId).not.toBe('stale-owner');
+        const lease = await manager2.acquire(key);
         await lease.release();
+        // manager1 was evicted; its release is best-effort.
+        await staleLease.release();
     });
     it('keeps owner metadata valid when heartbeat writes overlap', async () => {
         const manager = createResourceLockManager({
@@ -108,20 +107,21 @@ describe('resource lock manager', () => {
             staleLockTimeoutMs: 200,
         });
         const key = 'ios:simulator:iPhone 17 Pro:26.2';
-        const ownerFilePath = path.join(rootDir, hashResourceLockKey(key), 'owner.json');
         const actualWriteFile = fs.writeFile.bind(fs);
         const writeFileSpy = vi
             .spyOn(fs, 'writeFile')
             .mockImplementation(async (file, data, options) => {
-            if (typeof file === 'string' &&
-                file.startsWith(ownerFilePath) &&
-                file !== ownerFilePath) {
+            // Delay atomic temp-file writes to simulate overlapping heartbeat flushes.
+            if (typeof file === 'string' && file.startsWith(rootDir) && file.endsWith('.tmp')) {
                 await new Promise((resolve) => setTimeout(resolve, 25));
             }
             return await actualWriteFile(file, data, options);
         });
         try {
             const lease = await manager.acquire(key);
+            // Discover the owner file after acquire creates the key directory.
+            const [keyDirName] = await fs.readdir(rootDir);
+            const ownerFilePath = path.join(rootDir, keyDirName, 'owner.json');
             const initialOwner = JSON.parse(await fs.readFile(ownerFilePath, 'utf8'));
             await new Promise((resolve) => setTimeout(resolve, 80));
             for (let index = 0; index < 5; index += 1) {

package/dist/cli-args.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli-args.test.d.ts.map

package/dist/cli-args.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-args.test.d.ts","sourceRoot":"","sources":["../src/cli-args.test.ts"],"names":[],"mappings":""}

package/dist/cli-args.test.js

@@ -0,0 +1 @@
+export {};

package/dist/client-log-handler.d.ts

@@ -1,23 +1,22 @@
 import type { ReportableEvent } from '@react-native-harness/bundler-metro';
+import type { TestResult as JestTestResult } from '@jest/test-result';
 export type ClientLogEvent = Extract<ReportableEvent, {
     type: 'client_log';
 }>;
+export type ClientLogBuffer = NonNullable<JestTestResult['console']>;
+export type ClientLogEntry = ClientLogBuffer[number];
+export type ClientLogCollector = {
+    handleEvent: (event: ReportableEvent) => void;
+    flush: () => ClientLogBuffer;
+};
 /**
  * Formats a client log event data array into a string message.
  * Uses util.format for printf-style format specifier support (%s, %d, %j, etc.)
  */
 export declare const formatClientLogMessage: (data: unknown[]) => string;
 /**
- * Formats a client log event into a log line with styled level prefix.
+ * Formats a client log event into Jest's buffered console entry format.
  */
-export declare const formatClientLogLine: (event: ClientLogEvent) => string;
-/**
- * Handles a client_log event by formatting and logging it.
- * Returns true if the event was handled, false otherwise.
- */
-export declare const handleClientLogEvent: (event: ReportableEvent) => boolean;
-/**
- * Creates a client log event listener that can be added to the Metro reporter.
- */
-export declare const createClientLogListener: () => ((event: ReportableEvent) => void);
+export declare const formatClientLogEntry: (event: ClientLogEvent) => ClientLogEntry | null;
+export declare const createClientLogCollector: () => ClientLogCollector;
 //# sourceMappingURL=client-log-handler.d.ts.map

package/dist/client-log-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client-log-handler.d.ts","sourceRoot":"","sources":["../src/client-log-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAK3E,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC;AA6C9E;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,OAAO,EAAE,KAAG,MAKxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,cAAc,KAAG,MAI3D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,eAAe,KAAG,OAiB7D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAAO,CAAC,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAI3E,CAAC"}
+{"version":3,"file":"client-log-handler.d.ts","sourceRoot":"","sources":["../src/client-log-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGtE,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC;AAC9E,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC;AACrE,MAAM,MAAM,cAAc,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;AACrD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IAC9C,KAAK,EAAE,MAAM,eAAe,CAAC;CAC9B,CAAC;AAuBF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,OAAO,EAAE,KAAG,MAMxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,KACpB,cAAc,GAAG,IAYnB,CAAC;AAEF,eAAO,MAAM,wBAAwB,QAAO,kBAoB3C,CAAC"}

package/dist/client-log-handler.js

@@ -1,41 +1,19 @@
-import chalk from 'chalk';
 import util from 'node:util';
-import { log } from './logs.js';
 /**
- * Gets the display level for a log level.
+ * Gets the Jest console level for a client log level.
  * Note: Metro treats 'trace' as 'log' because Hermes doesn't include stack traces.
  */
-const getDisplayLevel = (level) => {
-    // Metro converts trace to log for display (Hermes doesn't provide stack traces)
-    if (level === 'trace') {
-        return 'LOG';
-    }
-    return level.toUpperCase();
-};
-/**
- * Creates a styled tag for a log level with colored box appearance.
- */
-const createLevelTag = (level) => {
-    const displayLevel = getDisplayLevel(level);
-    const label = ` ${displayLevel} `;
-    if (!chalk.supportsColor) {
-        return `[${displayLevel}]`;
-    }
+const getJestLogLevel = (level) => {
     switch (level) {
-        case 'error':
-            return chalk.reset.inverse.bold.red(label);
-        case 'warn':
-            return chalk.reset.inverse.bold.yellow(label);
-        case 'info':
-            return chalk.reset.inverse.bold.cyan(label);
-        case 'debug':
-            return chalk.reset.inverse.bold.blue(label);
+        case 'group':
+        case 'groupCollapsed':
+        case 'groupEnd':
+            return null;
         case 'trace':
-            // Trace displays as LOG but with a distinct color
-            return chalk.reset.inverse.bold.magenta(label);
+            return 'log';
         case 'log':
         default:
-            return chalk.reset.inverse.bold.white(label);
+            return level;
     }
 };
 /**
@@ -49,36 +27,36 @@ export const formatClientLogMessage = (data) => {
     return util.format(...data);
 };
 /**
- * Formats a client log event into a log line with styled level prefix.
- */
-export const formatClientLogLine = (event) => {
-    const tag = createLevelTag(event.level);
-    const message = formatClientLogMessage(event.data);
-    return `${tag} ${message}`;
-};
-/**
- * Handles a client_log event by formatting and logging it.
- * Returns true if the event was handled, false otherwise.
+ * Formats a client log event into Jest's buffered console entry format.
  */
-export const handleClientLogEvent = (event) => {
-    if (event.type !== 'client_log') {
-        return false;
+export const formatClientLogEntry = (event) => {
+    const logLevel = getJestLogLevel(event.level);
+    if (!logLevel) {
+        return null;
     }
-    // Skip group events - they don't produce output
-    if (event.level === 'group' ||
-        event.level === 'groupCollapsed' ||
-        event.level === 'groupEnd') {
-        return true;
-    }
-    const logLine = formatClientLogLine(event);
-    log(logLine);
-    return true;
+    const message = formatClientLogMessage(event.data);
+    return {
+        message,
+        origin: '',
+        type: logLevel,
+    };
 };
-/**
- * Creates a client log event listener that can be added to the Metro reporter.
- */
-export const createClientLogListener = () => {
-    return (event) => {
-        handleClientLogEvent(event);
+export const createClientLogCollector = () => {
+    let buffer = [];
+    return {
+        handleEvent: (event) => {
+            if (event.type !== 'client_log') {
+                return;
+            }
+            const entry = formatClientLogEntry(event);
+            if (entry) {
+                buffer.push(entry);
+            }
+        },
+        flush: () => {
+            const flushed = buffer;
+            buffer = [];
+            return flushed;
+        },
     };
 };

package/dist/crash-monitor.d.ts

@@ -0,0 +1,23 @@
+import { type AppMonitor, type HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { type NativeCrashPhase } from './errors.js';
+export declare class CrashWatchCancelledError extends Error {
+    constructor();
+}
+export type CrashWatch = {
+    readonly promise: Promise<never>;
+    cancel: () => void;
+};
+export type CrashMonitor = {
+    watch: (testFilePath: string, phase: NativeCrashPhase) => CrashWatch;
+    isAlive: () => boolean;
+    stop: () => Promise<void>;
+    start: () => Promise<void>;
+    reset: () => void;
+    dispose: () => Promise<void>;
+};
+export type CrashMonitorOptions = {
+    appMonitor: AppMonitor;
+    platformRunner: HarnessPlatformRunner;
+};
+export declare const createCrashMonitor: ({ appMonitor, platformRunner, }: CrashMonitorOptions) => CrashMonitor;
+//# sourceMappingURL=crash-monitor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"crash-monitor.d.ts","sourceRoot":"","sources":["../src/crash-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAIf,KAAK,qBAAqB,EAC3B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,aAAa,CAAC;AAKrB,qBAAa,wBAAyB,SAAQ,KAAK;;CAKlD;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACjC,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,KAAK,UAAU,CAAC;IACrE,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,qBAAqB,CAAC;CACvC,CAAC;AA6BF,eAAO,MAAM,kBAAkB,GAAI,iCAGhC,mBAAmB,KAAG,YA+KxB,CAAC"}

package/dist/crash-monitor.js

@@ -0,0 +1,176 @@
+import { NativeCrashError, } from './errors.js';
+import { logger } from '@react-native-harness/tools';
+const crashLogger = logger.child('crash');
+export class CrashWatchCancelledError extends Error {
+    constructor() {
+        super('Crash watch was cancelled');
+        this.name = 'CrashWatchCancelledError';
+    }
+}
+const mergeCrashDetails = (phase, initial, enriched, fallbackSummary) => ({
+    phase,
+    source: enriched?.source ?? initial?.source,
+    summary: enriched?.summary ?? initial?.summary ?? fallbackSummary,
+    signal: enriched?.signal ?? initial?.signal,
+    exceptionType: enriched?.exceptionType ?? initial?.exceptionType,
+    processName: enriched?.processName ?? initial?.processName,
+    pid: enriched?.pid ?? initial?.pid,
+    stackTrace: enriched?.stackTrace ?? initial?.stackTrace,
+    rawLines: enriched?.rawLines ?? initial?.rawLines,
+    artifactType: enriched?.artifactType ?? initial?.artifactType,
+    artifactPath: enriched?.artifactPath ?? initial?.artifactPath,
+});
+export const createCrashMonitor = ({ appMonitor, platformRunner, }) => {
+    let alive = false;
+    let monitoring = true;
+    let isResolvingCrash = false;
+    let disposed = false;
+    // Both updated when watch() is called so crashes are attributed to the
+    // correct test file and lifecycle phase.
+    let currentTestFilePath = '';
+    let currentPhase = 'startup';
+    const watchers = new Set();
+    const getCrashDetailsProvider = () => {
+        if ('getCrashDetails' in appMonitor) {
+            return appMonitor;
+        }
+        if (platformRunner.getCrashDetails) {
+            return platformRunner;
+        }
+        return null;
+    };
+    const notifyCrash = (err) => {
+        const pending = [...watchers];
+        watchers.clear();
+        for (const fn of pending)
+            fn(err);
+    };
+    const handleCrash = async (phase, details, fallbackSummary) => {
+        if (isResolvingCrash)
+            return;
+        isResolvingCrash = true;
+        alive = false;
+        crashLogger.debug('native crash detected (phase=%s)', phase);
+        for (const line of details?.rawLines ?? []) {
+            crashLogger.debug('%s', line);
+        }
+        try {
+            const enriched = await getCrashDetailsProvider()?.getCrashDetails?.({
+                processName: details?.processName,
+                pid: details?.pid,
+                occurredAt: Date.now(),
+            });
+            const merged = mergeCrashDetails(phase, details, enriched, fallbackSummary);
+            crashLogger.debug('crash details: %o', {
+                phase: merged.phase,
+                source: merged.source,
+                summary: merged.summary,
+                signal: merged.signal,
+                exceptionType: merged.exceptionType,
+                processName: merged.processName,
+                pid: merged.pid,
+            });
+            notifyCrash(new NativeCrashError(currentTestFilePath, merged));
+        }
+        finally {
+            isResolvingCrash = false;
+        }
+    };
+    const confirmAndHandleCrash = async (phase, details, fallbackSummary) => {
+        if (disposed || !monitoring)
+            return;
+        try {
+            const isRunning = await platformRunner.isAppRunning();
+            if (!isRunning) {
+                void handleCrash(phase, details, fallbackSummary);
+            }
+        }
+        catch (error) {
+            crashLogger.debug('crash confirmation failed', error);
+        }
+    };
+    const extractCrashDetails = (event) => event.crashDetails
+        ? {
+            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),
+        }
+        : undefined;
+    const appMonitorListener = (event) => {
+        if (disposed || !monitoring)
+            return;
+        if (event.type === 'app_started') {
+            alive = true;
+            return;
+        }
+        if (event.type === 'app_exited') {
+            const details = extractCrashDetails(event);
+            if (event.isConfirmed ?? event.source === 'polling') {
+                void handleCrash(currentPhase, details);
+            }
+            else {
+                void confirmAndHandleCrash(currentPhase, details);
+            }
+            return;
+        }
+        if (event.type === 'possible_crash') {
+            const details = extractCrashDetails(event);
+            const fallback = `possible crash signal (${event.source ?? 'unknown'})`;
+            if (event.isConfirmed) {
+                void handleCrash(currentPhase, details, fallback);
+            }
+            else {
+                void confirmAndHandleCrash(currentPhase, details, fallback);
+            }
+        }
+    };
+    appMonitor.addListener(appMonitorListener);
+    const watch = (testFilePath, phase) => {
+        currentTestFilePath = testFilePath;
+        currentPhase = phase;
+        let rejectFn;
+        const promise = new Promise((_, reject) => {
+            rejectFn = (err) => {
+                watchers.delete(rejectFn);
+                reject(err);
+            };
+            watchers.add(rejectFn);
+        });
+        const cancel = () => {
+            rejectFn(new CrashWatchCancelledError());
+        };
+        return { promise, cancel };
+    };
+    return {
+        watch,
+        isAlive: () => alive,
+        stop: async () => {
+            monitoring = false;
+            await appMonitor.stop();
+        },
+        start: async () => {
+            monitoring = true;
+            await appMonitor.start();
+        },
+        reset: () => {
+            alive = false;
+            watchers.clear();
+            isResolvingCrash = false;
+            currentTestFilePath = '';
+        },
+        dispose: async () => {
+            disposed = true;
+            monitoring = false;
+            watchers.clear();
+            isResolvingCrash = false;
+            appMonitor.removeListener(appMonitorListener);
+            await appMonitor.dispose();
+        },
+    };
+};

package/dist/event-mapper.d.ts

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1 @@
+{"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"}