@react-native-harness/jest 1.1.0-rc.2 → 1.1.0-rc.3

package/dist/__tests__/errors.test.js

@@ -1,5 +1,10 @@
 import { describe, expect, it } from 'vitest';
-import { NativeCrashError } from '../errors.js';
+import { NativeCrashError, PlatformReadyTimeoutError } from '../errors.js';
+describe('PlatformReadyTimeoutError', () => {
+    it('includes the configured timeout and config hint', () => {
+        expect(new PlatformReadyTimeoutError(300000).message).toBe('The platform did not become ready within 300000ms. Increase "platformReadyTimeout" if your device, simulator, or emulator needs more time to start.');
+    });
+});
 describe('NativeCrashError', () => {
     it('formats the extracted stack trace in the error message', () => {
         const error = new NativeCrashError('/tmp/crash.harness.ts', {

package/dist/__tests__/harness-cache.test.js

@@ -17,10 +17,10 @@ const platform = {
     platformId: 'ios',
     runner: '/virtual/platform-runner.js',
     config: {},
+    getResourceLockKey: () => 'ios:simulator:iPhone 17 Pro:26.2',
 };
 const createHarnessConfig = (overrides = {}) => ({
     appRegistryComponentName: 'App',
-    webSocketPort: 8081,
     disableViewFlattening: false,
     bridgeTimeout: 5000,
     entryPoint: 'index.js',

package/dist/__tests__/harness.test.js

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'node:events';
+import { HARNESS_BRIDGE_PATH } from '@react-native-harness/bridge';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { definePlugin } from '@react-native-harness/plugins';
 import { createCrashSupervisor } from '../crash-supervisor.js';
@@ -8,6 +9,9 @@ const mocks = vi.hoisted(() => ({
     getMetroInstance: vi.fn(),
     isMetroCacheReusable: vi.fn(() => false),
     logMetroCacheReused: vi.fn(),
+    logRunnerStarting: vi.fn(),
+    logRunnerStillWaitingInQueue: vi.fn(),
+    logRunnerWaitingInQueue: vi.fn(),
     waitForMetroBackedAppReady: vi.fn(),
 }));
 vi.mock('@react-native-harness/bundler-metro', async () => {
@@ -24,6 +28,9 @@ vi.mock('@react-native-harness/bridge/server', () => ({
 }));
 vi.mock('../logs.js', () => ({
     logMetroCacheReused: mocks.logMetroCacheReused,
+    logRunnerStarting: mocks.logRunnerStarting,
+    logRunnerStillWaitingInQueue: mocks.logRunnerStillWaitingInQueue,
+    logRunnerWaitingInQueue: mocks.logRunnerWaitingInQueue,
 }));
 vi.mock('@react-native-harness/tools', async () => {
     const actual = await vi.importActual('@react-native-harness/tools');
@@ -33,11 +40,12 @@ vi.mock('@react-native-harness/tools', async () => {
     };
 });
 import { getHarness, waitForAppReady } from '../harness.js';
-import { StartupStallError } from '../errors.js';
+import { PlatformReadyTimeoutError, StartupStallError } from '../errors.js';
 const createBridgeServer = () => {
     const emitter = new EventEmitter();
     return {
         serverBridge: {
+            ws: {},
             rpc: {
                 clients: [],
             },
@@ -81,6 +89,8 @@ const createReporter = () => {
 };
 const createMetroInstance = (overrides = {}) => ({
     events: createReporter(),
+    httpServer: {},
+    websocketEndpoints: {},
     waitUntilHealthy: vi.fn(async () => 'HTTP 200: packager-status:running'),
     prewarm: vi.fn(async () => false),
     dispose: vi.fn(async () => undefined),
@@ -128,6 +138,7 @@ const createHarnessConfig = (overrides = {}) => ({
     forwardClientLogs: false,
     maxAppRestarts: 2,
     metroPort: 8081,
+    platformReadyTimeout: 300_000,
     resetEnvironmentBetweenTestFiles: true,
     runners: [],
     unstable__enableMetroCache: false,
@@ -220,6 +231,70 @@ describe('waitForAppReady', () => {
     });
 });
 describe('getHarness', () => {
+    it('fails when the platform runner does not become ready within platformReadyTimeout', async () => {
+        const { serverBridge } = createBridgeServer();
+        const metroInstance = createMetroInstance();
+        mocks.getBridgeServer.mockResolvedValue(serverBridge);
+        mocks.getMetroInstance.mockResolvedValue(metroInstance);
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = vi.fn(async () => await new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new DOMException('The operation was aborted', 'AbortError'));
+            }, 20);
+        }));
+        const platform = {
+            config: {},
+            getResourceLockKey: () => 'ios:test-platform-ready-timeout',
+            name: 'ios',
+            platformId: 'ios',
+            runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+        };
+        await expect(getHarness(createHarnessConfig({
+            platformReadyTimeout: 10,
+        }), platform, '/tmp/project')).rejects.toBeInstanceOf(PlatformReadyTimeoutError);
+    });
+    it('passes a platform init signal to the runner factory', async () => {
+        const { serverBridge } = createBridgeServer();
+        const appMonitor = createAppMonitor();
+        const platformInstance = createPlatformRunner({
+            createAppMonitor: () => appMonitor.appMonitor,
+        });
+        const metroInstance = createMetroInstance();
+        mocks.getBridgeServer.mockResolvedValue(serverBridge);
+        mocks.getMetroInstance.mockResolvedValue(metroInstance);
+        const runner = vi.fn(async () => platformInstance);
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = runner;
+        const platform = {
+            config: {},
+            getResourceLockKey: () => 'ios:test-platform-init-signal',
+            name: 'ios',
+            platformId: 'ios',
+            runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+        };
+        const harness = await getHarness(createHarnessConfig(), platform, '/tmp/project');
+        expect(runner).toHaveBeenCalledWith(platform.config, expect.any(Object), expect.objectContaining({
+            signal: expect.any(AbortSignal),
+        }));
+        await harness.dispose();
+    });
+    it('falls back to a default resource lock key for platforms without getResourceLockKey', async () => {
+        const { serverBridge } = createBridgeServer();
+        const appMonitor = createAppMonitor();
+        const platformInstance = createPlatformRunner({
+            createAppMonitor: () => appMonitor.appMonitor,
+        });
+        const metroInstance = createMetroInstance();
+        mocks.getBridgeServer.mockResolvedValue(serverBridge);
+        mocks.getMetroInstance.mockResolvedValue(metroInstance);
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = vi.fn(async () => platformInstance);
+        const platform = {
+            config: {},
+            name: 'legacy-ios',
+            platformId: 'ios',
+            runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+        };
+        const harness = await getHarness(createHarnessConfig(), platform, '/tmp/project');
+        await harness.dispose();
+    });
     it('routes ensureAppReady through the shared Metro startup helper', async () => {
         const { serverBridge, emitReady } = createBridgeServer();
         const appMonitor = createAppMonitor();
@@ -249,8 +324,11 @@ describe('getHarness', () => {
             name: 'ios',
             platformId: 'ios',
             runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+            getResourceLockKey: () => 'ios:simulator:iPhone 17 Pro:26.2',
         };
-        const harness = await getHarness(createHarnessConfig(), platform, '/tmp/project');
+        const harness = await getHarness(createHarnessConfig({
+            bridgeTimeout: 1,
+        }), platform, '/tmp/project');
         await harness.ensureAppReady('/tmp/example.harness.ts');
         expect(mocks.waitForMetroBackedAppReady).toHaveBeenCalledTimes(1);
         expect(restartApp).toHaveBeenCalledWith({
@@ -292,8 +370,17 @@ describe('getHarness', () => {
             name: 'ios',
             platformId: 'ios',
             runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+            getResourceLockKey: () => 'ios:simulator:iPhone 17 Pro:26.2',
         };
         const harness = await getHarness(createHarnessConfig(), platform, '/tmp/project');
+        expect(mocks.getBridgeServer).toHaveBeenCalledWith(expect.objectContaining({
+            noServer: true,
+        }));
+        expect(mocks.getMetroInstance).toHaveBeenCalledWith(expect.objectContaining({
+            websocketEndpoints: {
+                [HARNESS_BRIDGE_PATH]: serverBridge.ws,
+            },
+        }), expect.any(AbortSignal));
         await harness.restart('/tmp/restart.harness.ts');
         expect(stopApp).toHaveBeenCalledTimes(1);
         expect(mocks.waitForMetroBackedAppReady).toHaveBeenCalledTimes(1);
@@ -326,7 +413,17 @@ describe('plugins', () => {
                 harness: {
                     beforeCreation: (ctx) => {
                         ctx.state.creationCount += 1;
-                        observedHooks.push(`beforeCreation:${ctx.platform.platformId}:${ctx.appLaunchOptions == null ? 'no-launch-options' : 'launch-options'}`);
+                        observedHooks.push(`beforeCreation:${ctx.platform.platformId}:${ctx.appLaunchOptions == null
+                            ? 'no-launch-options'
+                            : 'launch-options'}`);
+                    },
+                    beforeRun: (ctx) => {
+                        observedHooks.push(`beforeRun:${ctx.platform.platformId}:${ctx.appLaunchOptions == null
+                            ? 'no-launch-options'
+                            : 'launch-options'}`);
+                    },
+                    afterRun: (ctx) => {
+                        observedHooks.push(`afterRun:${ctx.state.creationCount}:${ctx.reason}`);
                     },
                     beforeDispose: (ctx) => {
                         observedHooks.push(`beforeDispose:${ctx.state.creationCount}:${ctx.reason}`);
@@ -358,6 +455,7 @@ describe('plugins', () => {
             name: 'ios',
             platformId: 'ios',
             runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+            getResourceLockKey: () => 'ios:simulator:iPhone 17 Pro:26.2',
         };
         const harness = await getHarness(createHarnessConfig({
             plugins: [plugin],
@@ -385,12 +483,58 @@ describe('plugins', () => {
         await harness.dispose();
         expect(observedHooks).toEqual([
             'beforeCreation:ios:launch-options',
+            'beforeRun:ios:launch-options',
             'runtime.ready:run-1:ios',
             'collection.started:example.harness.ts',
             'runtime.disconnected:bridge-disconnected',
+            'afterRun:1:normal',
             'beforeDispose:1:normal',
         ]);
     });
+    it('waits in queue before starting Metro and releases the lock on dispose', async () => {
+        const resourceKey = 'ios:simulator:iPhone 17 Pro:26.2';
+        const firstPlatformRunner = createPlatformRunner();
+        const secondPlatformRunner = createPlatformRunner();
+        const secondAppMonitor = createAppMonitor();
+        const firstMetroInstance = createMetroInstance();
+        const secondMetroInstance = createMetroInstance();
+        const firstBridge = createBridgeServer();
+        const secondBridge = createBridgeServer();
+        mocks.getBridgeServer
+            .mockResolvedValueOnce(firstBridge.serverBridge)
+            .mockResolvedValueOnce(secondBridge.serverBridge);
+        mocks.getMetroInstance
+            .mockResolvedValueOnce(firstMetroInstance)
+            .mockResolvedValueOnce(secondMetroInstance);
+        let invocationCount = 0;
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = vi.fn(async () => {
+            invocationCount += 1;
+            return invocationCount === 1
+                ? firstPlatformRunner
+                : createPlatformRunner({
+                    createAppMonitor: () => secondAppMonitor.appMonitor,
+                    dispose: secondPlatformRunner.dispose,
+                });
+        });
+        const platform = {
+            config: {},
+            name: 'ios',
+            platformId: 'ios',
+            runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+            getResourceLockKey: () => resourceKey,
+        };
+        const firstHarness = await getHarness(createHarnessConfig(), platform, '/tmp/project');
+        const secondHarnessPromise = getHarness(createHarnessConfig(), platform, '/tmp/project');
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+        expect(mocks.logRunnerWaitingInQueue).toHaveBeenCalledWith(platform);
+        expect(mocks.logRunnerStarting).not.toHaveBeenCalled();
+        expect(mocks.getMetroInstance).toHaveBeenCalledTimes(1);
+        await firstHarness.dispose();
+        const secondHarness = await secondHarnessPromise;
+        expect(mocks.logRunnerStarting).toHaveBeenCalledWith(platform);
+        expect(mocks.getMetroInstance).toHaveBeenCalledTimes(2);
+        await secondHarness.dispose();
+    });
 });
 describe('StartupStallError', () => {
     it('includes the configured timeout and attempt count', () => {

package/dist/__tests__/resource-lock.test.d.ts

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

package/dist/__tests__/resource-lock.test.d.ts.map

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

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

@@ -0,0 +1,103 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createResourceLockManager, hashResourceLockKey, } from '../resource-lock.js';
+describe('resource lock manager', () => {
+    let rootDir;
+    beforeEach(async () => {
+        rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'react-native-harness-resource-lock-test-'));
+    });
+    afterEach(async () => {
+        await fs.rm(rootDir, { recursive: true, force: true });
+    });
+    it('queues access in FIFO order', async () => {
+        const manager = createResourceLockManager({
+            rootDir,
+            pollIntervalMs: 5,
+            heartbeatIntervalMs: 20,
+            staleLockTimeoutMs: 200,
+        });
+        const order = [];
+        const firstLease = await manager.acquire('ios:simulator:iPhone 17 Pro:26.2');
+        const secondAcquire = manager
+            .acquire('ios:simulator:iPhone 17 Pro:26.2', {
+            onWait: () => {
+                order.push('waiting');
+            },
+        })
+            .then(async (lease) => {
+            order.push('acquired');
+            await lease.release();
+        });
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        expect(order).toEqual(['waiting']);
+        await firstLease.release();
+        await secondAcquire;
+        expect(order).toEqual(['waiting', 'acquired']);
+    });
+    it('removes the queued ticket when waiting is aborted', async () => {
+        const manager = createResourceLockManager({
+            rootDir,
+            pollIntervalMs: 5,
+            heartbeatIntervalMs: 20,
+            staleLockTimeoutMs: 200,
+        });
+        const key = 'android:emulator:Pixel_8_API_35';
+        const firstLease = await manager.acquire(key);
+        const controller = new AbortController();
+        const acquirePromise = manager.acquire(key, {
+            signal: controller.signal,
+        });
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        controller.abort();
+        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);
+        await firstLease.release();
+    });
+    it('keeps queued tickets alive while the waiting process is still active', async () => {
+        const manager = createResourceLockManager({
+            rootDir,
+            pollIntervalMs: 5,
+            heartbeatIntervalMs: 20,
+            staleLockTimeoutMs: 30,
+            isProcessActive: () => true,
+        });
+        const key = 'ios:simulator:iPhone 17 Pro:26.2';
+        const firstLease = await manager.acquire(key);
+        const secondAcquire = manager.acquire(key);
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        await firstLease.release();
+        const secondLease = await secondAcquire;
+        await secondLease.release();
+    });
+    it('reclaims a stale owner before granting the lock', async () => {
+        const manager = 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');
+        await lease.release();
+    });
+});

package/dist/action-hooks.d.ts

@@ -0,0 +1,9 @@
+import { type HarnessPlugin } from '@react-native-harness/plugins';
+import type { Config as HarnessConfig } from '@react-native-harness/config';
+import type { HarnessPlatform } from '@react-native-harness/platforms';
+type ActionHookState = {
+    _unused?: never;
+};
+export declare const createActionHooksPlugin: () => HarnessPlugin<ActionHookState, HarnessConfig, HarnessPlatform>;
+export {};
+//# sourceMappingURL=action-hooks.d.ts.map

package/dist/action-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-hooks.d.ts","sourceRoot":"","sources":["../src/action-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAGvE,KAAK,eAAe,GAAG;IACrB,OAAO,CAAC,EAAE,KAAK,CAAC;CACjB,CAAC;AAuBF,eAAO,MAAM,uBAAuB,QAAO,aAAa,CACtD,eAAe,EACf,aAAa,EACb,eAAe,CA6Bb,CAAC"}

package/dist/action-hooks.js

@@ -0,0 +1,36 @@
+import { definePlugin, } from '@react-native-harness/plugins';
+import { spawn } from '@react-native-harness/tools';
+const getInlineHookScript = (name) => {
+    const value = process.env[name]?.trim();
+    return value ? value : null;
+};
+const runInlineHook = async (script) => {
+    const env = Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] != null));
+    await spawn('bash', ['-lc', script], {
+        env,
+        cwd: process.env.HARNESS_PROJECT_ROOT,
+    });
+};
+export const createActionHooksPlugin = () => definePlugin({
+    name: 'github-action-hooks',
+    createState: () => ({}),
+    hooks: {
+        harness: {
+            beforeRun: async () => {
+                const script = getInlineHookScript('PRE_RUN_HOOK');
+                if (!script) {
+                    return;
+                }
+                await runInlineHook(script);
+            },
+            afterRun: async (ctx) => {
+                const script = getInlineHookScript('AFTER_RUN_HOOK');
+                if (!script) {
+                    return;
+                }
+                process.env.HARNESS_EXIT_CODE = ctx.status === 'passed' ? '0' : '1';
+                await runInlineHook(script);
+            },
+        },
+    },
+});

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/crash-monitor.d.ts

@@ -0,0 +1,16 @@
+import { HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { BridgeServer } from '@react-native-harness/bridge/server';
+export type CrashMonitor = {
+    startMonitoring(testFilePath: string): Promise<never>;
+    stopMonitoring(): void;
+    markIntentionalRestart(): void;
+    clearIntentionalRestart(): void;
+    dispose(): void;
+};
+export type CrashMonitorOptions = {
+    interval: number;
+    platformRunner: HarnessPlatformRunner;
+    bridgeServer: BridgeServer;
+};
+export declare const createCrashMonitor: ({ interval, platformRunner, bridgeServer, }: 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,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAInE,MAAM,MAAM,YAAY,GAAG;IACzB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACtD,cAAc,IAAI,IAAI,CAAC;IACvB,sBAAsB,IAAI,IAAI,CAAC;IAC/B,uBAAuB,IAAI,IAAI,CAAC;IAChC,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,qBAAqB,CAAC;IACtC,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,6CAIhC,mBAAmB,KAAG,YAqFxB,CAAC"}

package/dist/crash-monitor.js

@@ -0,0 +1,75 @@
+import { NativeCrashError } from './errors.js';
+import { logger } from '@react-native-harness/tools';
+export const createCrashMonitor = ({ interval, platformRunner, bridgeServer, }) => {
+    let pollingInterval = null;
+    let isIntentionalRestart = false;
+    let currentTestFilePath = null;
+    let rejectFn = null;
+    const handleDisconnect = () => {
+        // Verify if it's actually a crash by checking if app is still running
+        if (!isIntentionalRestart && currentTestFilePath) {
+            // Capture the value to avoid it being null when setTimeout callback runs
+            const testFilePath = currentTestFilePath;
+            logger.debug('Bridge disconnected, checking if app crashed');
+            // Use a slight delay to allow the OS to clean up the process
+            setTimeout(async () => {
+                const isRunning = await platformRunner.isAppRunning();
+                if (!isRunning && !isIntentionalRestart && rejectFn) {
+                    logger.debug(`Native crash detected during: ${testFilePath}`);
+                    rejectFn(new NativeCrashError(testFilePath));
+                }
+            }, 100);
+        }
+    };
+    const startMonitoring = (testFilePath) => {
+        currentTestFilePath = testFilePath;
+        return new Promise((_, reject) => {
+            rejectFn = reject;
+            // Listen for bridge disconnect as early indicator
+            bridgeServer.on('disconnect', handleDisconnect);
+            // Poll for app running status
+            pollingInterval = setInterval(async () => {
+                // Skip check during intentional restarts
+                if (isIntentionalRestart) {
+                    return;
+                }
+                try {
+                    const isRunning = await platformRunner.isAppRunning();
+                    if (!isRunning && currentTestFilePath) {
+                        logger.debug(`Native crash detected during: ${currentTestFilePath}`);
+                        stopMonitoring();
+                        reject(new NativeCrashError(currentTestFilePath));
+                    }
+                }
+                catch (error) {
+                    logger.error('Error checking app status:', error);
+                }
+            }, interval);
+        });
+    };
+    const stopMonitoring = () => {
+        if (pollingInterval) {
+            clearInterval(pollingInterval);
+            pollingInterval = null;
+        }
+        bridgeServer.off('disconnect', handleDisconnect);
+        currentTestFilePath = null;
+        rejectFn = null;
+    };
+    const markIntentionalRestart = () => {
+        isIntentionalRestart = true;
+    };
+    const clearIntentionalRestart = () => {
+        isIntentionalRestart = false;
+    };
+    const dispose = () => {
+        stopMonitoring();
+    };
+    return {
+        startMonitoring,
+        stopMonitoring,
+        markIntentionalRestart,
+        clearIntentionalRestart,
+        dispose,
+    };
+};

package/dist/errors.d.ts

@@ -11,6 +11,10 @@ export declare class RunnerNotFoundError extends HarnessError {
 export declare class InitializationTimeoutError extends HarnessError {
     constructor();
 }
+export declare class PlatformReadyTimeoutError extends HarnessError {
+    readonly timeout: number;
+    constructor(timeout: number);
+}
 export type NativeCrashPhase = 'startup' | 'execution';
 export type NativeCrashDetails = AppCrashDetails & {
     phase: NativeCrashPhase;

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

package/dist/errors.js

@@ -20,6 +20,14 @@ export class InitializationTimeoutError extends HarnessError {
         this.name = 'InitializationTimeoutError';
     }
 }
+export class PlatformReadyTimeoutError extends HarnessError {
+    timeout;
+    constructor(timeout) {
+        super(`The platform did not become ready within ${timeout}ms. Increase "platformReadyTimeout" if your device, simulator, or emulator needs more time to start.`);
+        this.timeout = timeout;
+        this.name = 'PlatformReadyTimeoutError';
+    }
+}
 const buildNativeCrashMessage = ({ phase, summary, signal, exceptionType, processName, pid, stackTrace, artifactType, }) => {
     const lines = [
         phase === 'startup'
@@ -28,8 +36,7 @@ const buildNativeCrashMessage = ({ phase, summary, signal, exceptionType, proces
     ];
     const hasCrashBlock = summary?.includes('\n') ?? false;
     const shouldRenderSummary = Boolean(summary) &&
-        !(!hasCrashBlock &&
-            artifactType === 'ios-crash-report');
+        !(!hasCrashBlock && artifactType === 'ios-crash-report');
     if (shouldRenderSummary && summary) {
         lines.push('');
         lines.push(summary);

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"}