@react-native-harness/jest 1.3.0 → 1.4.0-rc.1

package/dist/__tests__/index.test.js

@@ -8,6 +8,7 @@ const resolveUndefined = async () => undefined;
 const mockSession = {
     config: { metroPort: 8081 },
     context: {},
+    onTestRunnerEvent: vi.fn(() => () => undefined),
     ensureAppReady: vi.fn(resolveUndefined),
     runTestFile: vi.fn(async () => ({
         name: '',
@@ -41,40 +42,88 @@ const makeTest = () => ({
     context: { config: {} },
 });
 const makeGlobalConfig = (overrides = {}) => ({ rootDir: '/project', watch: false, watchAll: false, collectCoverage: false, ...overrides });
+const typedMockExecuteRun = mockExecuteRun;
+const makeTestCaseStartPayload = () => [
+    '/test/example.ts',
+    {
+        ancestorTitles: [],
+        fullName: 'suite case',
+        mode: undefined,
+        title: 'case',
+        startedAt: 1,
+    },
+];
+const makeTestCaseResultPayload = () => [
+    '/test/example.ts',
+    {
+        ancestorTitles: [],
+        duration: 1,
+        failureDetails: [],
+        failureMessages: [],
+        fullName: 'suite case',
+        numPassingAsserts: 1,
+        startedAt: 1,
+        status: 'passed',
+        title: 'case',
+    },
+];
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 beforeEach(() => {
     vi.clearAllMocks();
     mockSession.dispose.mockResolvedValue(undefined);
-    mockExecuteRun.mockResolvedValue(undefined);
+    typedMockExecuteRun.mockResolvedValue(undefined);
     mockCreateHarnessSession.mockResolvedValue(mockSession);
 });
 describe('JestHarness', () => {
     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());
+            await runner.runTests([makeTest()], makeWatcher(), 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());
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), 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());
+            await runner.runTests([makeTest()], makeWatcher(), 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());
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
             expect(mockCreateHarnessSession).toHaveBeenCalledTimes(2);
         });
+        it('emits registered Jest events', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            const listener = vi.fn();
+            const eventPayload = makeTestCaseStartPayload();
+            runner.on('test-case-start', listener);
+            typedMockExecuteRun.mockImplementationOnce(async (_session, _tests, _watcher, emitEvent) => {
+                await emitEvent('test-case-start', ...eventPayload);
+            });
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
+            expect(listener).toHaveBeenCalledWith(eventPayload);
+        });
+        it('stops emitting after listener unsubscribe', async () => {
+            const runner = new JestHarness(makeGlobalConfig());
+            const listener = vi.fn();
+            const unsubscribe = runner.on('test-case-result', listener);
+            const eventPayload = makeTestCaseResultPayload();
+            unsubscribe();
+            typedMockExecuteRun.mockImplementationOnce(async (_session, _tests, _watcher, emitEvent) => {
+                await emitEvent('test-case-result', ...eventPayload);
+            });
+            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
+            expect(listener).not.toHaveBeenCalled();
+        });
     });
     describe('error handling', () => {
         it('converts HarnessError into a formatted string before throwing', async () => {
@@ -83,17 +132,17 @@ describe('JestHarness', () => {
             }
             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');
+            await expect(runner.runTests([makeTest()], makeWatcher(), 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);
+            await expect(runner.runTests([makeTest()], makeWatcher(), 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');
+            await expect(runner.runTests([makeTest()], makeWatcher(), { serial: false })).rejects.toThrow('Parallel test running is not supported');
         });
     });
 });

package/dist/__tests__/test-file-platform-filter.test.d.ts

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

package/dist/__tests__/test-file-platform-filter.test.d.ts.map

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

package/dist/__tests__/test-file-platform-filter.test.js

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { createPlatformSkippedTestResult, getHarnessTestFilePlatform, shouldRunHarnessTestFile, } from '../test-file-platform-filter.js';
+const knownPlatformIds = new Set(['android', 'ios', 'web', 'vega']);
+describe('getHarnessTestFilePlatform', () => {
+    it('returns null for shared harness test files', () => {
+        expect(getHarnessTestFilePlatform('/tests/smoke.harness.ts', knownPlatformIds)).toBeNull();
+        expect(getHarnessTestFilePlatform('/tests/smoke.harness.tsx', knownPlatformIds)).toBeNull();
+        expect(getHarnessTestFilePlatform('/tests/smoke.harness.mjs', knownPlatformIds)).toBeNull();
+    });
+    it('returns the platform id for platform-specific harness test files', () => {
+        expect(getHarnessTestFilePlatform('/tests/kotlin.android.harness.ts', knownPlatformIds)).toBe('android');
+        expect(getHarnessTestFilePlatform('/tests/swift.ios.harness.ts', knownPlatformIds)).toBe('ios');
+        expect(getHarnessTestFilePlatform('/tests/browser.web.harness.ts', knownPlatformIds)).toBe('web');
+    });
+    it('returns null when the segment before .harness is not a known platform id', () => {
+        expect(getHarnessTestFilePlatform('/tests/smoke.harness.ts', knownPlatformIds)).toBeNull();
+        expect(getHarnessTestFilePlatform('/tests/custom.foo.harness.ts', knownPlatformIds)).toBeNull();
+    });
+});
+describe('shouldRunHarnessTestFile', () => {
+    it('runs shared harness test files on every platform', () => {
+        expect(shouldRunHarnessTestFile('/tests/smoke.harness.ts', 'android', knownPlatformIds)).toBe(true);
+        expect(shouldRunHarnessTestFile('/tests/smoke.harness.ts', 'ios', knownPlatformIds)).toBe(true);
+    });
+    it('runs platform-specific files only on the matching platform', () => {
+        expect(shouldRunHarnessTestFile('/tests/kotlin.android.harness.ts', 'android', knownPlatformIds)).toBe(true);
+        expect(shouldRunHarnessTestFile('/tests/kotlin.android.harness.ts', 'ios', knownPlatformIds)).toBe(false);
+        expect(shouldRunHarnessTestFile('/tests/swift.ios.harness.ts', 'ios', knownPlatformIds)).toBe(true);
+        expect(shouldRunHarnessTestFile('/tests/swift.ios.harness.ts', 'android', knownPlatformIds)).toBe(false);
+    });
+});
+describe('createPlatformSkippedTestResult', () => {
+    it('marks the entire test file as skipped', () => {
+        const result = createPlatformSkippedTestResult('/tests/swift.ios.harness.ts');
+        expect(result.skipped).toBe(true);
+        expect(result.numPassingTests).toBe(0);
+        expect(result.numFailingTests).toBe(0);
+        expect(result.numPendingTests).toBe(1);
+        expect(result.testResults).toHaveLength(1);
+        expect(result.testResults[0]).toEqual(expect.objectContaining({
+            status: 'skipped',
+            title: 'swift.ios.harness.ts',
+            fullName: 'swift.ios.harness.ts',
+        }));
+        expect(result.testFilePath).toBe('/tests/swift.ios.harness.ts');
+    });
+});

package/dist/crash-monitor.d.ts

@@ -1,4 +1,4 @@
-import { type AppMonitor, type HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { type AppSession } from '@react-native-harness/platforms';
 import { type NativeCrashPhase } from './errors.js';
 export declare class CrashWatchCancelledError extends Error {
     constructor();
@@ -13,11 +13,12 @@ export type CrashMonitor = {
     stop: () => Promise<void>;
     start: () => Promise<void>;
     reset: () => void;
+    setAppSession: (session: AppSession | null) => void;
+    handleBridgeDisconnect: () => void;
     dispose: () => Promise<void>;
 };
 export type CrashMonitorOptions = {
-    appMonitor: AppMonitor;
-    platformRunner: HarnessPlatformRunner;
+    appSession?: AppSession | null;
 };
-export declare const createCrashMonitor: ({ appMonitor, platformRunner, }: CrashMonitorOptions) => CrashMonitor;
+export declare const createCrashMonitor: ({ appSession: initialAppSession, }?: CrashMonitorOptions) => CrashMonitor;
 //# sourceMappingURL=crash-monitor.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"crash-monitor.d.ts","sourceRoot":"","sources":["../src/crash-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,UAAU,EAKhB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAKL,KAAK,gBAAgB,EAEtB,MAAM,aAAa,CAAC;AAOrB,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,aAAa,EAAE,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,KAAK,IAAI,CAAC;IACpD,sBAAsB,EAAE,MAAM,IAAI,CAAC;IACnC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;CAChC,CAAC;AA0EF,eAAO,MAAM,kBAAkB,GAAI,qCAEhC,mBAAwB,KAAG,YAyL7B,CAAC"}

package/dist/crash-monitor.js

@@ -1,136 +1,143 @@
-import { NativeCrashError, } from './errors.js';
+import { NativeCrashError, RuntimeDisconnectError, } from './errors.js';
 import { logger } from '@react-native-harness/tools';
 const crashLogger = logger.child('crash');
+const CRASH_CLASSIFICATION_SETTLE_MS = 1500;
+const CRASH_LOG_WINDOW_MS = 3000;
 export class CrashWatchCancelledError extends Error {
     constructor() {
         super('Crash watch was cancelled');
         this.name = 'CrashWatchCancelledError';
     }
 }
-const mergeCrashDetails = (phase, initial, enriched, fallbackSummary) => ({
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const isCrashIndicator = (line) => /uncaught exception|terminating app due to|fatal error|EXC_[A-Z_]+|termination reason|crash|abort/i.test(line) || /\bSIG[A-Z]{2,}\b/.test(line);
+const getMatchingCrashLines = (logs, occurredAt) => logs
+    .filter((log) => Math.abs(log.occurredAt - occurredAt) <= CRASH_LOG_WINDOW_MS)
+    .map((log) => log.line)
+    .filter(isCrashIndicator);
+const buildNativeCrashDetails = (phase, rawLines, summary) => ({
     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,
+    source: rawLines.length > 0 ? 'logs' : 'bridge',
+    summary: rawLines.length > 0 ? rawLines.join('\n') : summary,
+    rawLines: rawLines.length > 0 ? rawLines : undefined,
 });
-export const createCrashMonitor = ({ appMonitor, platformRunner, }) => {
+const getStatePid = (state) => {
+    if (state && 'pid' in state) {
+        return state.pid;
+    }
+    return undefined;
+};
+const mergeCrashDetails = (fallback, extracted) => {
+    if (!extracted) {
+        return fallback;
+    }
+    return {
+        ...fallback,
+        ...extracted,
+        phase: fallback.phase,
+        source: extracted.source ?? fallback.source,
+        summary: extracted.summary ?? fallback.summary,
+        rawLines: extracted.rawLines ?? fallback.rawLines,
+    };
+};
+const buildRuntimeDisconnectDetails = (phase, rawLines) => ({
+    phase,
+    source: 'bridge',
+    summary: 'The runtime bridge disconnected, but the app session still appears to be running.',
+    rawLines: rawLines.length > 0 ? rawLines : undefined,
+});
+export const createCrashMonitor = ({ appSession: initialAppSession = null, } = {}) => {
     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 appSession = null;
+    let pendingTimer = null;
     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 notifyFailure = (err) => {
         const pending = [...watchers];
         watchers.clear();
         for (const fn of pending)
             fn(err);
     };
-    const handleCrash = async (phase, details, fallbackSummary) => {
-        if (isResolvingCrash)
+    const clearPendingTimer = () => {
+        if (pendingTimer) {
+            clearTimeout(pendingTimer);
+            pendingTimer = null;
+        }
+    };
+    const classify = async (pending, trigger) => {
+        if (disposed || !monitoring || isResolvingCrash) {
             return;
-        isResolvingCrash = true;
-        alive = false;
-        crashLogger.debug('native crash detected (phase=%s)', phase);
-        for (const line of details?.rawLines ?? []) {
-            crashLogger.debug('%s', line);
         }
+        isResolvingCrash = true;
         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));
+            const session = appSession;
+            const state = await session?.getState();
+            const logs = session?.getLogs() ?? [];
+            const rawLines = getMatchingCrashLines(logs, pending.occurredAt);
+            if (state?.status === 'running' && trigger === 'bridge-disconnect') {
+                crashLogger.debug('runtime bridge disconnected without confirmed app death');
+                notifyFailure(new RuntimeDisconnectError(pending.testFilePath, buildRuntimeDisconnectDetails(pending.phase, rawLines)));
+                return;
+            }
+            alive = false;
+            crashLogger.debug('native crash detected (phase=%s)', pending.phase);
+            for (const line of rawLines) {
+                crashLogger.debug('%s', line);
+            }
+            const fallbackSummary = trigger === 'bridge-disconnect'
+                ? 'The app process exited after the runtime bridge disconnected, but no crash log lines were found.'
+                : 'The app process exited, but no crash log lines were found.';
+            const details = buildNativeCrashDetails(pending.phase, rawLines, fallbackSummary);
+            const extractedDetails = session?.getCrashDetails
+                ? await session
+                    .getCrashDetails({
+                    occurredAt: pending.occurredAt,
+                    pid: getStatePid(state),
+                    processName: details.processName,
+                    testFilePath: pending.testFilePath,
+                })
+                    .catch((error) => {
+                    crashLogger.warn('failed to extract native crash details: %s', error);
+                    return null;
+                })
+                : null;
+            notifyFailure(new NativeCrashError(pending.testFilePath, mergeCrashDetails(details, extractedDetails)));
         }
         finally {
             isResolvingCrash = false;
+            pendingTimer = null;
         }
     };
-    const confirmAndHandleCrash = async (phase, details, fallbackSummary) => {
-        if (disposed || !monitoring)
+    const startCrashResolution = (trigger) => {
+        if (disposed || !monitoring || isResolvingCrash) {
             return;
-        try {
-            const isRunning = await platformRunner.isAppRunning();
-            if (!isRunning) {
-                void handleCrash(phase, details, fallbackSummary);
-            }
-        }
-        catch (error) {
-            crashLogger.debug('crash confirmation failed', error);
         }
+        clearPendingTimer();
+        const pending = {
+            testFilePath: currentTestFilePath,
+            phase: currentPhase,
+            occurredAt: Date.now(),
+        };
+        pendingTimer = setTimeout(() => {
+            void classify(pending, trigger);
+        }, trigger === 'bridge-disconnect' ? CRASH_CLASSIFICATION_SETTLE_MS : 0);
     };
-    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;
-        }
+    const appSessionListener = (event) => {
         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);
-            }
+            startCrashResolution('app-exit');
         }
     };
-    appMonitor.addListener(appMonitorListener);
+    const setAppSession = (session) => {
+        appSession?.removeListener(appSessionListener);
+        appSession = session;
+        alive = Boolean(session);
+        session?.addListener(appSessionListener);
+    };
+    setAppSession(initialAppSession);
     const watch = (testFilePath, phase) => {
         currentTestFilePath = testFilePath;
         currentPhase = phase;
@@ -152,25 +159,32 @@ export const createCrashMonitor = ({ appMonitor, platformRunner, }) => {
         isAlive: () => alive,
         stop: async () => {
             monitoring = false;
-            await appMonitor.stop();
+            clearPendingTimer();
+            await sleep(0);
         },
         start: async () => {
             monitoring = true;
-            await appMonitor.start();
         },
         reset: () => {
-            alive = false;
+            alive = Boolean(appSession);
             watchers.clear();
             isResolvingCrash = false;
             currentTestFilePath = '';
+            clearPendingTimer();
+        },
+        setAppSession,
+        handleBridgeDisconnect: () => {
+            startCrashResolution('bridge-disconnect');
         },
         dispose: async () => {
             disposed = true;
             monitoring = false;
             watchers.clear();
             isResolvingCrash = false;
-            appMonitor.removeListener(appMonitorListener);
-            await appMonitor.dispose();
+            clearPendingTimer();
+            appSession?.removeListener(appSessionListener);
+            appSession = null;
+            alive = false;
         },
     };
 };

package/dist/errors.d.ts

@@ -24,6 +24,9 @@ export type NativeCrashPhase = 'startup' | 'execution';
 export type NativeCrashDetails = AppCrashDetails & {
     phase: NativeCrashPhase;
 };
+export type RuntimeDisconnectDetails = AppCrashDetails & {
+    phase: NativeCrashPhase;
+};
 export declare class NativeCrashError extends HarnessError {
     readonly testFilePath: string;
     readonly details: NativeCrashDetails;
@@ -31,4 +34,11 @@ export declare class NativeCrashError extends HarnessError {
     constructor(testFilePath: string, details: NativeCrashDetails, lastKnownTest?: string | undefined);
     get phase(): NativeCrashPhase;
 }
+export declare class RuntimeDisconnectError extends HarnessError {
+    readonly testFilePath: string;
+    readonly details: RuntimeDisconnectDetails;
+    constructor(testFilePath: string, details: RuntimeDisconnectDetails);
+    get phase(): NativeCrashPhase;
+}
+export type HarnessRuntimeFailure = NativeCrashError | RuntimeDisconnectError;
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EACL,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,GACzB,MAAM,qCAAqC,CAAC;AAE7C,qBAAa,sBAAuB,SAAQ,YAAY;;CAKvD;AAED,qBAAa,mBAAoB,SAAQ,YAAY;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAED,qBAAa,0BAA2B,SAAQ,YAAY;;CAK3D;AAED,qBAAa,yBAA0B,SAAQ,YAAY;aAC7B,OAAO,EAAE,MAAM;gBAAf,OAAO,EAAE,MAAM;CAM5C;AAED,qBAAa,4BAA6B,SAAQ,YAAY;aAE1C,WAAW,EAAE,MAAM;aACnB,QAAQ,EAAE,MAAM;gBADhB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM;CAQnC;AAED,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,WAAW,CAAC;AAEvD,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG;IACjD,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAmDF,qBAAa,gBAAiB,SAAQ,YAAY;aAE9B,YAAY,EAAE,MAAM;aACpB,OAAO,EAAE,kBAAkB;aAC3B,aAAa,CAAC,EAAE,MAAM;gBAFtB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,kBAAkB,EAC3B,aAAa,CAAC,EAAE,MAAM,YAAA;IAOxC,IAAI,KAAK,qBAER;CACF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,YAAY,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EACL,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,GACzB,MAAM,qCAAqC,CAAC;AAE7C,qBAAa,sBAAuB,SAAQ,YAAY;;CAKvD;AAED,qBAAa,mBAAoB,SAAQ,YAAY;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAED,qBAAa,0BAA2B,SAAQ,YAAY;;CAK3D;AAED,qBAAa,yBAA0B,SAAQ,YAAY;aAC7B,OAAO,EAAE,MAAM;gBAAf,OAAO,EAAE,MAAM;CAM5C;AAED,qBAAa,4BAA6B,SAAQ,YAAY;aAE1C,WAAW,EAAE,MAAM;aACnB,QAAQ,EAAE,MAAM;gBADhB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM;CAQnC;AAED,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,WAAW,CAAC;AAEvD,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG;IACjD,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,eAAe,GAAG;IACvD,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAmEF,qBAAa,gBAAiB,SAAQ,YAAY;aAE9B,YAAY,EAAE,MAAM;aACpB,OAAO,EAAE,kBAAkB;aAC3B,aAAa,CAAC,EAAE,MAAM;gBAFtB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,kBAAkB,EAC3B,aAAa,CAAC,EAAE,MAAM,YAAA;IAOxC,IAAI,KAAK,qBAER;CACF;AA0BD,qBAAa,sBAAuB,SAAQ,YAAY;aAEpC,YAAY,EAAE,MAAM;aACpB,OAAO,EAAE,wBAAwB;gBADjC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,wBAAwB;IAOnD,IAAI,KAAK,qBAER;CACF;AAED,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,GAAG,sBAAsB,CAAC"}

package/dist/errors.js

@@ -1,4 +1,4 @@
-import { HarnessError } from '@react-native-harness/tools';
+import { formatPath, HarnessError } from '@react-native-harness/tools';
 export { StartupStallError, } from '@react-native-harness/bundler-metro';
 export class NoRunnerSpecifiedError extends HarnessError {
     constructor() {
@@ -39,12 +39,21 @@ export class MetroPortRangeExhaustedError extends HarnessError {
         this.name = 'MetroPortRangeExhaustedError';
     }
 }
-const buildNativeCrashMessage = ({ phase, summary, signal, exceptionType, processName, pid, stackTrace, artifactType, }) => {
+const buildNativeCrashMessage = ({ phase, summary, signal, exceptionType, processName, pid, stackTrace, artifactType, artifactPath, enrichmentArtifacts, }) => {
     const lines = [
         phase === 'startup'
             ? 'The native app crashed while preparing to run this test file.'
             : 'The native app crashed during test execution.',
     ];
+    lines.push(artifactPath
+        ? `Harness extracted the crash log: ${formatPath(artifactPath)}`
+        : "Harness couldn't extract the crash log.");
+    if (enrichmentArtifacts && enrichmentArtifacts.length > 0) {
+        lines.push('Additional crash artifacts:');
+        for (const artifact of enrichmentArtifacts) {
+            lines.push(`  - ${formatPath(artifact.artifactPath)}`);
+        }
+    }
     const hasCrashBlock = summary?.includes('\n') ?? false;
     const shouldRenderSummary = Boolean(summary) &&
         !(!hasCrashBlock && artifactType === 'ios-crash-report');
@@ -89,3 +98,33 @@ export class NativeCrashError extends HarnessError {
         return this.details.phase;
     }
 }
+const buildRuntimeDisconnectMessage = ({ phase, summary, rawLines, }) => {
+    const lines = [
+        phase === 'startup'
+            ? 'The native runtime disconnected while preparing to run this test file.'
+            : 'The native runtime disconnected during test execution.',
+    ];
+    if (summary) {
+        lines.push('');
+        lines.push(summary);
+    }
+    if (rawLines && rawLines.length > 0 && summary !== rawLines.join('\n')) {
+        lines.push('');
+        lines.push(...rawLines);
+    }
+    return lines.join('\n');
+};
+export class RuntimeDisconnectError extends HarnessError {
+    testFilePath;
+    details;
+    constructor(testFilePath, details) {
+        super(buildRuntimeDisconnectMessage(details));
+        this.testFilePath = testFilePath;
+        this.details = details;
+        this.name = 'RuntimeDisconnectError';
+        this.stack = `${this.name}: ${this.message.split('\n')[0]}`;
+    }
+    get phase() {
+        return this.details.phase;
+    }
+}

package/dist/execute-run.d.ts

@@ -1,4 +1,6 @@
-import type { OnTestFailure, OnTestStart, OnTestSuccess, Test, TestWatcher, Config } from 'jest-runner';
+import type { Test, TestWatcher, Config, TestEvents } from 'jest-runner';
 import { type HarnessSession } from './harness-session.js';
-export declare const executeRun: (session: HarnessSession, tests: Array<Test>, watcher: TestWatcher, onStart: OnTestStart, onResult: OnTestSuccess, onFailure: OnTestFailure, globalConfig: Config.GlobalConfig) => Promise<void>;
+type EmitTestEvent = <Name extends keyof TestEvents>(eventName: Name, ...eventData: TestEvents[Name]) => Promise<void>;
+export declare const executeRun: (session: HarnessSession, tests: Array<Test>, watcher: TestWatcher, emitEvent: EmitTestEvent, globalConfig: Config.GlobalConfig) => Promise<void>;
+export {};
 //# sourceMappingURL=execute-run.d.ts.map

package/dist/execute-run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute-run.d.ts","sourceRoot":"","sources":["../src/execute-run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,WAAW,EACX,aAAa,EACb,IAAI,EACJ,WAAW,EACX,MAAM,EACP,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,sBAAsB,CAAC;AAsCjF,eAAO,MAAM,UAAU,GACrB,SAAS,cAAc,EACvB,OAAO,KAAK,CAAC,IAAI,CAAC,EAClB,SAAS,WAAW,EACpB,SAAS,WAAW,EACpB,UAAU,aAAa,EACvB,WAAW,aAAa,EACxB,cAAc,MAAM,CAAC,YAAY,KAChC,OAAO,CAAC,IAAI,CA8Id,CAAC"}
+{"version":3,"file":"execute-run.d.ts","sourceRoot":"","sources":["../src/execute-run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,WAAW,EACX,MAAM,EACN,UAAU,EACX,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,sBAAsB,CAAC;AAsBjF,KAAK,aAAa,GAAG,CAAC,IAAI,SAAS,MAAM,UAAU,EACjD,SAAS,EAAE,IAAI,EACf,GAAG,SAAS,EAAE,UAAU,CAAC,IAAI,CAAC,KAC3B,OAAO,CAAC,IAAI,CAAC,CAAC;AAmFnB,eAAO,MAAM,UAAU,GACrB,SAAS,cAAc,EACvB,OAAO,KAAK,CAAC,IAAI,CAAC,EAClB,SAAS,WAAW,EACpB,WAAW,aAAa,EACxB,cAAc,MAAM,CAAC,YAAY,KAChC,OAAO,CAAC,IAAI,CA8Ld,CAAC"}