@react-native-harness/jest 1.0.0 → 1.1.0-rc.1

package/dist/__tests__/crash-supervisor.test.d.ts

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

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

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

package/dist/__tests__/crash-supervisor.test.js

@@ -0,0 +1,151 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createCrashSupervisor } from '../crash-supervisor.js';
+const createMockAppMonitor = (options) => {
+    const listeners = new Set();
+    const noop = async () => undefined;
+    const appMonitor = {
+        start: noop,
+        stop: noop,
+        dispose: noop,
+        addListener: (listener) => {
+            listeners.add(listener);
+        },
+        removeListener: (listener) => {
+            listeners.delete(listener);
+        },
+    };
+    if (options?.getCrashDetails) {
+        appMonitor.getCrashDetails = options.getCrashDetails;
+    }
+    const emit = (event) => {
+        for (const listener of listeners) {
+            listener(event);
+        }
+    };
+    return {
+        appMonitor,
+        emit,
+    };
+};
+const createPlatformRunner = ({ isAppRunning, getCrashDetails, }) => ({
+    startApp: async () => undefined,
+    restartApp: async () => undefined,
+    stopApp: async () => undefined,
+    dispose: async () => undefined,
+    isAppRunning,
+    createAppMonitor: () => {
+        throw new Error('Not used in unit tests');
+    },
+    getCrashDetails,
+});
+describe('crash-supervisor', () => {
+    it('rejects the active test when the app exits during launch', async () => {
+        const monitor = createMockAppMonitor();
+        const supervisor = createCrashSupervisor({
+            appMonitor: monitor.appMonitor,
+            platformRunner: createPlatformRunner({
+                isAppRunning: vi.fn().mockResolvedValue(false),
+            }),
+        });
+        supervisor.beginLaunch('/tmp/startup.harness.ts');
+        const crashPromise = supervisor.waitForCrash('/tmp/startup.harness.ts');
+        const expectation = expect(crashPromise).rejects.toMatchObject({
+            name: 'NativeCrashError',
+            phase: 'startup',
+            details: {
+                signal: 'SIGSEGV',
+                processName: 'com.harnessplayground',
+            },
+        });
+        monitor.emit({
+            type: 'app_exited',
+            source: 'logs',
+            crashDetails: {
+                source: 'logs',
+                signal: 'SIGSEGV',
+                processName: 'com.harnessplayground',
+                rawLines: ['Fatal signal 11 (SIGSEGV)'],
+            },
+        });
+        await expectation;
+        await supervisor.dispose();
+    });
+    it('treats polling exit events as immediately confirmed crashes', async () => {
+        const monitor = createMockAppMonitor();
+        const isAppRunning = vi.fn().mockResolvedValue(true);
+        const supervisor = createCrashSupervisor({
+            appMonitor: monitor.appMonitor,
+            platformRunner: createPlatformRunner({
+                isAppRunning,
+            }),
+        });
+        supervisor.beginLaunch('/tmp/polling-exit.harness.ts');
+        const crashPromise = supervisor.waitForCrash('/tmp/polling-exit.harness.ts');
+        monitor.emit({ type: 'app_exited', source: 'polling' });
+        await expect(crashPromise).rejects.toMatchObject({
+            name: 'NativeCrashError',
+            phase: 'startup',
+        });
+        expect(isAppRunning).not.toHaveBeenCalled();
+        await supervisor.dispose();
+    });
+    it('does not reject when monitoring is stopped', async () => {
+        const monitor = createMockAppMonitor();
+        const supervisor = createCrashSupervisor({
+            appMonitor: monitor.appMonitor,
+            platformRunner: createPlatformRunner({
+                isAppRunning: vi.fn().mockResolvedValue(false),
+            }),
+        });
+        supervisor.beginTestRun('/tmp/restart.harness.ts');
+        await supervisor.stop();
+        const reject = vi.fn();
+        void supervisor.waitForCrash('/tmp/restart.harness.ts').catch(reject);
+        monitor.emit({ type: 'app_exited', source: 'polling' });
+        await Promise.resolve();
+        expect(reject).not.toHaveBeenCalled();
+        await supervisor.dispose();
+    });
+    it('prefers crash details from the started app monitor over the runner', async () => {
+        const monitorGetCrashDetails = vi.fn().mockResolvedValue({
+            source: 'logs',
+            summary: 'full crash block',
+            rawLines: ['full crash block'],
+        });
+        const runnerGetCrashDetails = vi.fn().mockResolvedValue({
+            source: 'logs',
+            summary: 'runner details',
+            rawLines: ['runner details'],
+        });
+        const monitor = createMockAppMonitor({
+            getCrashDetails: monitorGetCrashDetails,
+        });
+        const supervisor = createCrashSupervisor({
+            appMonitor: monitor.appMonitor,
+            platformRunner: createPlatformRunner({
+                isAppRunning: vi.fn().mockResolvedValue(false),
+                getCrashDetails: runnerGetCrashDetails,
+            }),
+        });
+        supervisor.beginTestRun('/tmp/monitor-details.harness.ts');
+        const crashPromise = supervisor.waitForCrash('/tmp/monitor-details.harness.ts');
+        monitor.emit({
+            type: 'possible_crash',
+            source: 'logs',
+            crashDetails: {
+                source: 'logs',
+                processName: 'com.harnessplayground',
+                pid: 1234,
+                rawLines: ['partial line'],
+            },
+        });
+        await expect(crashPromise).rejects.toMatchObject({
+            details: {
+                summary: 'full crash block',
+            },
+        });
+        expect(monitorGetCrashDetails).toHaveBeenCalled();
+        expect(runnerGetCrashDetails).not.toHaveBeenCalled();
+        await supervisor.dispose();
+    });
+});

package/dist/__tests__/errors.test.d.ts

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

package/dist/__tests__/errors.test.d.ts.map

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

package/dist/__tests__/errors.test.js

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { NativeCrashError } from '../errors.js';
+describe('NativeCrashError', () => {
+    it('formats the extracted stack trace in the error message', () => {
+        const error = new NativeCrashError('/tmp/crash.harness.ts', {
+            phase: 'execution',
+            processName: 'HarnessPlayground',
+            pid: 1234,
+            signal: 'SIGTRAP',
+            exceptionType: 'EXC_BREAKPOINT',
+            stackTrace: [
+                '0 AppDelegate.crashIfRequested() (AppDelegate.swift:31)',
+                '1 AppDelegate.application(_:didFinishLaunchingWithOptions:) (AppDelegate.swift:56)',
+            ],
+        });
+        expect(error.message).toContain('  0 AppDelegate.crashIfRequested() (AppDelegate.swift:31)');
+        expect(error.message).toContain('  1 AppDelegate.application(_:didFinishLaunchingWithOptions:) (AppDelegate.swift:56)');
+    });
+    it('omits single-line iOS summaries from the rendered error message', () => {
+        const error = new NativeCrashError('/tmp/crash.harness.ts', {
+            phase: 'startup',
+            artifactType: 'ios-crash-report',
+            summary: '2026-03-12 13:46:18.154 Df HarnessPlayground[18007:65e716] [com.apple.dt.xctest:Default] notify_get_state check indicated test daemon not ready.',
+            processName: 'HarnessPlayground',
+            pid: 18007,
+            signal: 'SIGABRT',
+            exceptionType: 'EXC_CRASH',
+        });
+        expect(error.message).not.toContain('notify_get_state check indicated test daemon not ready');
+        expect(error.message).toContain('Signal: SIGABRT');
+        expect(error.message).toContain('Exception: EXC_CRASH');
+        expect(error.message).toContain('Process: HarnessPlayground (pid 18007)');
+    });
+    it('does not duplicate stack frames when the summary already contains a crash block', () => {
+        const frame = '03-13 07:59:44.943 20373 20373 E AndroidRuntime: \tat com.harnessplayground.MainActivity.onCreate(MainActivity.kt:38)';
+        const error = new NativeCrashError('/tmp/crash.harness.ts', {
+            phase: 'startup',
+            summary: [
+                '--------- beginning of crash',
+                '03-13 07:59:44.943 20373 20373 E AndroidRuntime: FATAL EXCEPTION: main',
+                frame,
+            ].join('\n'),
+            stackTrace: [frame],
+        });
+        expect(error.message.match(/MainActivity\.onCreate\(MainActivity\.kt:38\)/g)).toHaveLength(1);
+    });
+    it('collapses the native crash stack header so jest does not reprint multiline messages', () => {
+        const error = new NativeCrashError('/tmp/crash.harness.ts', {
+            phase: 'startup',
+            summary: ['line one', 'line two'].join('\n'),
+        });
+        expect(error.stack).toBe('NativeCrashError: The native app crashed while preparing to run this test file.');
+    });
+});

package/dist/__tests__/harness.test.d.ts

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

package/dist/__tests__/harness.test.d.ts.map

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

package/dist/__tests__/harness.test.js

@@ -0,0 +1,106 @@
+import { EventEmitter } from 'node:events';
+import { describe, expect, it, vi } from 'vitest';
+import { waitForAppReady } from '../harness.js';
+import { createCrashSupervisor } from '../crash-supervisor.js';
+const createBridgeServer = () => {
+    const emitter = new EventEmitter();
+    return {
+        serverBridge: {
+            on: emitter.on.bind(emitter),
+            once: emitter.once.bind(emitter),
+            off: emitter.off.bind(emitter),
+        },
+        emitReady: () => {
+            emitter.emit('ready');
+        },
+    };
+};
+const createAppMonitor = () => {
+    const listeners = new Set();
+    return {
+        start: async () => undefined,
+        stop: async () => undefined,
+        dispose: async () => undefined,
+        addListener: (listener) => {
+            listeners.add(listener);
+        },
+        removeListener: (listener) => {
+            listeners.delete(listener);
+        },
+    };
+};
+const createPlatformRunner = (restartApp) => ({
+    startApp: async () => undefined,
+    restartApp,
+    stopApp: async () => undefined,
+    dispose: async () => undefined,
+    isAppRunning: async () => true,
+    createAppMonitor: createAppMonitor,
+});
+describe('waitForAppReady', () => {
+    it('passes launch options to the initial launch', async () => {
+        const { serverBridge, emitReady } = createBridgeServer();
+        const restartApp = vi.fn().mockResolvedValue(undefined);
+        const platformInstance = createPlatformRunner(restartApp);
+        const crashSupervisor = createCrashSupervisor({
+            appMonitor: createAppMonitor(),
+            platformRunner: platformInstance,
+        });
+        const promise = waitForAppReady({
+            serverBridge,
+            platformInstance,
+            bridgeTimeout: 5000,
+            testFilePath: '/tmp/test.harness.ts',
+            crashSupervisor,
+            appLaunchOptions: {
+                extras: {
+                    mode: 'startup',
+                },
+            },
+        });
+        await Promise.resolve();
+        expect(restartApp).toHaveBeenCalledWith({
+            extras: {
+                mode: 'startup',
+            },
+        });
+        emitReady();
+        await promise;
+        await crashSupervisor.dispose();
+    });
+    it('does not retry launch when the app never becomes ready', async () => {
+        vi.useFakeTimers();
+        const { serverBridge } = createBridgeServer();
+        const restartApp = vi.fn().mockResolvedValue(undefined);
+        const platformInstance = createPlatformRunner(restartApp);
+        const crashSupervisor = createCrashSupervisor({
+            appMonitor: createAppMonitor(),
+            platformRunner: platformInstance,
+        });
+        const promise = waitForAppReady({
+            serverBridge,
+            platformInstance,
+            bridgeTimeout: 1000,
+            testFilePath: '/tmp/test.harness.ts',
+            crashSupervisor,
+            appLaunchOptions: {
+                extras: {
+                    mode: 'startup',
+                },
+            },
+        });
+        await Promise.resolve();
+        await vi.advanceTimersByTimeAsync(1000);
+        await expect(promise).rejects.toMatchObject({
+            name: 'AbortError',
+        });
+        expect(restartApp).toHaveBeenCalledTimes(1);
+        expect(restartApp).toHaveBeenCalledWith({
+            extras: {
+                mode: 'startup',
+            },
+        });
+        await crashSupervisor.dispose();
+        vi.useRealTimers();
+    });
+});

package/dist/crash-supervisor.d.ts

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

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

package/dist/crash-supervisor.js

@@ -0,0 +1,209 @@
+import { NativeCrashError, } from './errors.js';
+import { logger } from '@react-native-harness/tools';
+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) {
+            logger.debug(`Ignoring crash signal without active test: ${reason}`);
+            return;
+        }
+        isResolvingCrash = true;
+        logger.debug(`Native crash detected during ${activeTestFilePath} (state: ${state}, reason: ${reason || '(none)'})`);
+        for (const line of details?.rawLines ?? []) {
+            logger.debug(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);
+            logger.debug('Crash details:', {
+                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) {
+                handleCrash(reason, details);
+            }
+        }
+        catch (error) {
+            logger.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/errors.d.ts

@@ -1,4 +1,5 @@
 import { HarnessError } from '@react-native-harness/tools';
+import type { AppCrashDetails } from '@react-native-harness/platforms';
 export declare class NoRunnerSpecifiedError extends HarnessError {
     constructor();
 }
@@ -9,12 +10,15 @@ export declare class RunnerNotFoundError extends HarnessError {
 export declare class InitializationTimeoutError extends HarnessError {
     constructor();
 }
-export declare class MaxAppRestartsError extends HarnessError {
-    constructor(attempts: number);
-}
+export type NativeCrashPhase = 'startup' | 'execution';
+export type NativeCrashDetails = AppCrashDetails & {
+    phase: NativeCrashPhase;
+};
 export declare class NativeCrashError extends HarnessError {
     readonly testFilePath: string;
+    readonly details: NativeCrashDetails;
     readonly lastKnownTest?: string | undefined;
-    constructor(testFilePath: string, lastKnownTest?: string | undefined);
+    constructor(testFilePath: string, details: NativeCrashDetails, lastKnownTest?: string | undefined);
+    get phase(): NativeCrashPhase;
 }
 //# 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;AAE3D,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,mBAAoB,SAAQ,YAAY;gBACvC,QAAQ,EAAE,MAAM;CAO7B;AAED,qBAAa,gBAAiB,SAAQ,YAAY;aAE9B,YAAY,EAAE,MAAM;aACpB,aAAa,CAAC,EAAE,MAAM;gBADtB,YAAY,EAAE,MAAM,EACpB,aAAa,CAAC,EAAE,MAAM,YAAA;CAKzC"}
+{"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;AAEvE,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,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,WAAW,CAAC;AAEvD,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG;IACjD,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAsDF,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"}

package/dist/errors.js

@@ -19,20 +19,54 @@ export class InitializationTimeoutError extends HarnessError {
         this.name = 'InitializationTimeoutError';
     }
 }
-export class MaxAppRestartsError extends HarnessError {
-    constructor(attempts) {
-        super(`App failed to start after ${attempts} attempts. ` +
-            `No bundling activity detected within timeout period.`);
-        this.name = 'MaxAppRestartsError';
+const buildNativeCrashMessage = ({ phase, summary, signal, exceptionType, processName, pid, stackTrace, artifactType, }) => {
+    const lines = [
+        phase === 'startup'
+            ? 'The native app crashed while preparing to run this test file.'
+            : 'The native app crashed during test execution.',
+    ];
+    const hasCrashBlock = summary?.includes('\n') ?? false;
+    const shouldRenderSummary = Boolean(summary) &&
+        !(!hasCrashBlock &&
+            artifactType === 'ios-crash-report');
+    if (shouldRenderSummary && summary) {
+        lines.push('');
+        lines.push(summary);
     }
-}
+    if (!hasCrashBlock && signal) {
+        lines.push(`Signal: ${signal}`);
+    }
+    if (!hasCrashBlock && exceptionType) {
+        lines.push(`Exception: ${exceptionType}`);
+    }
+    if (!hasCrashBlock && processName && pid !== undefined) {
+        lines.push(`Process: ${processName} (pid ${pid})`);
+    }
+    else if (!hasCrashBlock && processName) {
+        lines.push(`Process: ${processName}`);
+    }
+    else if (!hasCrashBlock && pid !== undefined) {
+        lines.push(`PID: ${pid}`);
+    }
+    if (!hasCrashBlock && stackTrace && stackTrace.length > 0) {
+        lines.push('');
+        lines.push(...stackTrace.map((line) => `  ${line}`));
+    }
+    return lines.join('\n');
+};
 export class NativeCrashError extends HarnessError {
     testFilePath;
+    details;
     lastKnownTest;
-    constructor(testFilePath, lastKnownTest) {
-        super('The native app crashed during test execution.');
+    constructor(testFilePath, details, lastKnownTest) {
+        super(buildNativeCrashMessage(details));
         this.testFilePath = testFilePath;
+        this.details = details;
         this.lastKnownTest = lastKnownTest;
         this.name = 'NativeCrashError';
+        this.stack = `${this.name}: ${this.message.split('\n')[0]}`;
+    }
+    get phase() {
+        return this.details.phase;
     }
 }