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

package/dist/__tests__/execute-run.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi, beforeEach } from 'vitest';
 import { NativeCrashError, StartupStallError } from '../errors.js';
-import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
+import { AppBridgeDisconnectedError, DeviceNotRespondingError, } from '@react-native-harness/bridge/server';
 import { executeRun } from '../execute-run.js';
 const resolveUndefined = async () => undefined;
 // Mock the file-runner so we control what jestResult/harnessResult each test returns
@@ -66,18 +66,38 @@ const makeSession = (overrides = {}) => ({
         host: undefined,
         resetEnvironmentBetweenTestFiles: false,
         detectNativeCrashes: true,
+        runners: [
+            { platformId: 'android', name: 'android' },
+            { platformId: 'ios', name: 'ios' },
+        ],
+    },
+    context: {
+        platform: {
+            platformId: 'android',
+            name: 'android',
+            runner: '/virtual/android-runner.js',
+            cli: '/virtual/android-cli.js',
+            config: {},
+        },
     },
-    context: {},
     ensureAppReady: vi.fn(resolveUndefined),
     runTestFile: vi.fn(async () => makeHarnessResult()),
     restartApp: vi.fn(resolveUndefined),
     resetCrashState: vi.fn(),
     flushClientLogs: vi.fn(() => []),
     callHook: vi.fn(resolveUndefined),
+    onTestRunnerEvent: vi.fn(() => () => undefined),
     setRunState: vi.fn(),
     dispose: vi.fn(resolveUndefined),
     ...overrides,
 });
+const makeEmitEvent = () => {
+    const calls = [];
+    const emitEvent = (async (...eventData) => {
+        calls.push(eventData);
+    });
+    return { emitEvent, calls };
+};
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -92,7 +112,7 @@ describe('executeRun', () => {
             const session = makeSession({
                 callHook: vi.fn(async (name) => { hookNames.push(name); }),
             });
-            await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+            await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
             expect(hookNames[0]).toBe('run:started');
             expect(hookNames[hookNames.length - 1]).toBe('run:finished');
         });
@@ -101,7 +121,7 @@ describe('executeRun', () => {
             const session = makeSession({
                 callHook: vi.fn(async (name) => { hookNames.push(name); }),
             });
-            await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts')], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+            await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
             const fileHooks = hookNames.filter((n) => n === 'test-file:started' || n === 'test-file:finished');
             expect(fileHooks).toEqual([
                 'test-file:started', 'test-file:finished',
@@ -114,24 +134,35 @@ describe('executeRun', () => {
                 callHook: vi.fn(async (name) => { hookNames.push(name); }),
                 ensureAppReady: vi.fn(async () => { throw new Error('unexpected'); }),
             });
-            await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+            await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
             expect(hookNames).toContain('run:finished');
         });
     });
     describe('happy path', () => {
-        it('calls onStart, ensureAppReady, runTestFile, onResult in order', async () => {
+        it('emits file start, ensureAppReady, runTestFile, file success in order', async () => {
             const order = [];
             const session = makeSession({
                 ensureAppReady: vi.fn(async () => { order.push('ensureAppReady'); }),
             });
-            const onStart = vi.fn(async () => { order.push('onStart'); });
-            const onResult = vi.fn(async () => { order.push('onResult'); });
+            const emitEvent = (async (eventName, ..._eventData) => {
+                if (eventName === 'test-file-start') {
+                    order.push('test-file-start');
+                }
+                if (eventName === 'test-file-success') {
+                    order.push('test-file-success');
+                }
+            });
             mockRunHarnessTestFile.mockImplementation(async () => {
                 order.push('runTestFile');
                 return makeFileRunResult();
             });
-            await executeRun(session, [makeTest()], makeWatcher(), onStart, onResult, vi.fn(), makeGlobalConfig());
-            expect(order).toEqual(['onStart', 'ensureAppReady', 'runTestFile', 'onResult']);
+            await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
+            expect(order).toEqual([
+                'test-file-start',
+                'ensureAppReady',
+                'runTestFile',
+                'test-file-success',
+            ]);
         });
         it('accumulates passing test counts in run:finished summary', async () => {
             let finishedPayload;
@@ -142,7 +173,7 @@ describe('executeRun', () => {
                 }),
             });
             mockRunHarnessTestFile.mockResolvedValue(makeFileRunResult({ jestResult: makeJestResult({ numPassingTests: 3 }) }));
-            await executeRun(session, [makeTest(), makeTest('/b.ts')], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+            await executeRun(session, [makeTest(), makeTest('/b.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
             const payload = finishedPayload;
             expect(payload.summary.passed).toBe(6);
             expect(payload.status).toBe('passed');
@@ -154,34 +185,124 @@ describe('executeRun', () => {
                     .mockReturnValueOnce([])
                     .mockReturnValueOnce(clientLogs),
             });
-            const onResult = vi.fn();
-            await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), onResult, vi.fn(), makeGlobalConfig());
+            const { emitEvent, calls } = makeEmitEvent();
+            await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
             expect(session.flushClientLogs).toHaveBeenCalledTimes(2);
-            expect(onResult).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ console: clientLogs }));
+            expect(calls).toContainEqual([
+                'test-file-success',
+                expect.anything(),
+                expect.objectContaining({ console: clientLogs }),
+            ]);
+        });
+        it('emits test-case events before file success', async () => {
+            let testRunnerListener;
+            const { emitEvent, calls: emittedEvents } = makeEmitEvent();
+            const session = makeSession({
+                onTestRunnerEvent: vi.fn((listener) => {
+                    testRunnerListener = listener;
+                    return () => undefined;
+                }),
+            });
+            mockRunHarnessTestFile.mockImplementation(async () => {
+                testRunnerListener?.({
+                    type: 'test-started',
+                    file: 'example.ts',
+                    suite: 'suite',
+                    name: 'works',
+                    ancestorTitles: ['suite'],
+                    fullName: 'suite works',
+                    startedAt: 10,
+                    declarationMode: 'only',
+                });
+                testRunnerListener?.({
+                    type: 'test-finished',
+                    file: 'example.ts',
+                    suite: 'suite',
+                    name: 'works',
+                    ancestorTitles: ['suite'],
+                    fullName: 'suite works',
+                    startedAt: 10,
+                    declarationMode: 'only',
+                    duration: 5,
+                    status: 'passed',
+                });
+                return makeFileRunResult();
+            });
+            await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
+            expect(emittedEvents).toEqual([
+                ['test-file-start', expect.anything()],
+                [
+                    'test-case-start',
+                    'example.ts',
+                    expect.objectContaining({
+                        ancestorTitles: ['suite'],
+                        fullName: 'suite works',
+                        mode: 'only',
+                        title: 'works',
+                        startedAt: 10,
+                    }),
+                ],
+                [
+                    'test-case-result',
+                    'example.ts',
+                    expect.objectContaining({
+                        ancestorTitles: ['suite'],
+                        fullName: 'suite works',
+                        numPassingAsserts: 1,
+                        startedAt: 10,
+                        status: 'passed',
+                        title: 'works',
+                    }),
+                ],
+                ['test-file-success', expect.anything(), expect.anything()],
+            ]);
         });
     });
     describe('runtime failures', () => {
         it('passes StartupStallError to onFailure with an empty stack', async () => {
-            const onFailure = vi.fn();
+            const { emitEvent, calls } = makeEmitEvent();
             const session = makeSession({
                 ensureAppReady: vi.fn().mockRejectedValue(new StartupStallError(1500, 3)),
             });
-            await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), onFailure, makeGlobalConfig());
-            expect(onFailure).toHaveBeenCalledWith(expect.objectContaining({ path: '/test/example.ts' }), expect.objectContaining({ message: expect.stringContaining('1500'), stack: '' }));
+            await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
+            expect(calls).toContainEqual([
+                'test-file-failure',
+                expect.objectContaining({ path: '/test/example.ts' }),
+                expect.objectContaining({ message: expect.stringContaining('1500'), stack: '' }),
+            ]);
         });
         it('passes DeviceNotRespondingError to onFailure with an empty stack', async () => {
-            const onFailure = vi.fn();
+            const { emitEvent, calls } = makeEmitEvent();
             const session = makeSession({
                 ensureAppReady: vi.fn().mockRejectedValue(new DeviceNotRespondingError('runTests', [])),
             });
-            await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), onFailure, makeGlobalConfig());
-            expect(onFailure).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ stack: '' }));
+            await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
+            expect(calls).toContainEqual([
+                'test-file-failure',
+                expect.anything(),
+                expect.objectContaining({ stack: '' }),
+            ]);
+        });
+        it('passes AppBridgeDisconnectedError to onFailure with an empty stack', async () => {
+            const { emitEvent, calls } = makeEmitEvent();
+            const session = makeSession({
+                ensureAppReady: vi.fn().mockRejectedValue(new AppBridgeDisconnectedError('app-disconnected')),
+            });
+            await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
+            expect(calls).toContainEqual([
+                'test-file-failure',
+                expect.anything(),
+                expect.objectContaining({
+                    message: expect.stringContaining('The app bridge disconnected during test execution.'),
+                    stack: '',
+                }),
+            ]);
         });
         it('calls resetCrashState after a NativeCrashError', async () => {
             const session = makeSession({
                 ensureAppReady: vi.fn().mockRejectedValue(new NativeCrashError('example.ts', { phase: 'execution', source: 'polling' })),
             });
-            await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+            await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
             expect(session.resetCrashState).toHaveBeenCalled();
         });
         it('counts runtime failures in the summary', async () => {
@@ -193,7 +314,7 @@ describe('executeRun', () => {
                 }),
                 ensureAppReady: vi.fn().mockRejectedValue(new StartupStallError(1000, 2)),
             });
-            await executeRun(session, [makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+            await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
             const payload = finishedPayload;
             expect(payload.summary.failed).toBe(1);
             expect(payload.status).toBe('failed');
@@ -205,10 +326,10 @@ describe('executeRun', () => {
             const session = makeSession({
                 callHook: vi.fn(async (name) => { hookNames.push(name); }),
             });
-            const onStart = vi.fn();
-            await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts')], makeWatcher(true /* interrupted */), onStart, vi.fn(), vi.fn(), makeGlobalConfig());
+            const { emitEvent, calls } = makeEmitEvent();
+            await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts')], makeWatcher(true /* interrupted */), emitEvent, makeGlobalConfig());
             // No test was started; watcher was already interrupted.
-            expect(onStart).not.toHaveBeenCalled();
+            expect(calls).not.toContainEqual(['test-file-start', expect.anything()]);
             expect(hookNames).toContain('run:finished');
         });
     });
@@ -219,11 +340,54 @@ describe('executeRun', () => {
                     metroPort: 8081,
                     resetEnvironmentBetweenTestFiles: true,
                     detectNativeCrashes: false,
+                    runners: [
+                        { platformId: 'android', name: 'android' },
+                        { platformId: 'ios', name: 'ios' },
+                    ],
                 },
             });
-            await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts'), makeTest('/c.ts')], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeGlobalConfig());
+            await executeRun(session, [makeTest('/a.ts'), makeTest('/b.ts'), makeTest('/c.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
             // restartApp should be called for tests 2 and 3, not test 1.
             expect(session.restartApp).toHaveBeenCalledTimes(2);
         });
     });
+    describe('platform-specific test files', () => {
+        it('skips files for other platforms without running them on the device', async () => {
+            const session = makeSession();
+            const { emitEvent, calls } = makeEmitEvent();
+            await executeRun(session, [
+                makeTest('/project/smoke.harness.ts'),
+                makeTest('/project/kotlin.android.harness.ts'),
+                makeTest('/project/swift.ios.harness.ts'),
+            ], makeWatcher(), emitEvent, makeGlobalConfig());
+            expect(mockRunHarnessTestFile).toHaveBeenCalledTimes(2);
+            expect(mockRunHarnessTestFile).toHaveBeenCalledWith(expect.objectContaining({ testPath: '/project/smoke.harness.ts' }));
+            expect(mockRunHarnessTestFile).toHaveBeenCalledWith(expect.objectContaining({ testPath: '/project/kotlin.android.harness.ts' }));
+            expect(session.ensureAppReady).toHaveBeenCalledTimes(2);
+            expect(calls).toContainEqual([
+                'test-file-success',
+                expect.objectContaining({ path: '/project/swift.ios.harness.ts' }),
+                expect.objectContaining({ skipped: true }),
+            ]);
+        });
+        it('does not restart the app for skipped platform-specific files', async () => {
+            const session = makeSession({
+                config: {
+                    metroPort: 8081,
+                    resetEnvironmentBetweenTestFiles: true,
+                    detectNativeCrashes: false,
+                    runners: [
+                        { platformId: 'android', name: 'android' },
+                        { platformId: 'ios', name: 'ios' },
+                    ],
+                },
+            });
+            await executeRun(session, [
+                makeTest('/project/swift.ios.harness.ts'),
+                makeTest('/project/kotlin.android.harness.ts'),
+            ], makeWatcher(), vi.fn(), makeGlobalConfig());
+            expect(session.restartApp).not.toHaveBeenCalled();
+            expect(mockRunHarnessTestFile).toHaveBeenCalledTimes(1);
+        });
+    });
 });

package/dist/__tests__/fixtures/mock-platform-runner.d.ts

@@ -0,0 +1,7 @@
+import type { HarnessPlatformInitOptions, HarnessPlatformRunner } from '@react-native-harness/platforms';
+import type { Config as HarnessConfig } from '@react-native-harness/config';
+declare global {
+    var __HARNESS_TEST_PLATFORM_RUNNER__: HarnessPlatformRunner | undefined;
+}
+export default function mockPlatformRunner(_platformConfig: Record<string, unknown>, _harnessConfig: HarnessConfig, _init: HarnessPlatformInitOptions): Promise<HarnessPlatformRunner>;
+//# sourceMappingURL=mock-platform-runner.d.ts.map

package/dist/__tests__/fixtures/mock-platform-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-platform-runner.d.ts","sourceRoot":"","sources":["../../../src/__tests__/fixtures/mock-platform-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,0BAA0B,EAC1B,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE5E,OAAO,CAAC,MAAM,CAAC;IACb,IAAI,gCAAgC,EAChC,qBAAqB,GACrB,SAAS,CAAC;CACf;AAED,wBAA8B,kBAAkB,CAC9C,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACxC,cAAc,EAAE,aAAa,EAC7B,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,qBAAqB,CAAC,CAMhC"}

package/dist/__tests__/fixtures/mock-platform-runner.js

@@ -0,0 +1,6 @@
+export default async function mockPlatformRunner(_platformConfig, _harnessConfig, _init) {
+    if (!globalThis.__HARNESS_TEST_PLATFORM_RUNNER__) {
+        throw new Error('Missing __HARNESS_TEST_PLATFORM_RUNNER__ test fixture');
+    }
+    return globalThis.__HARNESS_TEST_PLATFORM_RUNNER__;
+}

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

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

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

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

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

@@ -0,0 +1,74 @@
+import { describe, expect, it, vi } from 'vitest';
+import { waitForBridgeDisconnectOrTimeout, waitForStartupCrash, } from '../harness-session.js';
+const createConnection = () => ({
+    device: {
+        platform: 'ios',
+        manufacturer: 'Apple',
+        model: 'iPhone',
+        osVersion: '18.0',
+    },
+    runTests: vi.fn(),
+});
+const createBridge = (connection) => {
+    let currentConnection = connection;
+    let disconnectedListener = null;
+    return {
+        get connection() {
+            return currentConnection;
+        },
+        on: vi.fn((event, listener) => {
+            if (event === 'disconnected') {
+                disconnectedListener = listener;
+            }
+        }),
+        off: vi.fn((event, listener) => {
+            if (event === 'disconnected' && disconnectedListener === listener) {
+                disconnectedListener = null;
+            }
+        }),
+        disconnect: () => {
+            currentConnection = null;
+            disconnectedListener?.();
+        },
+    };
+};
+describe('waitForBridgeDisconnectOrTimeout', () => {
+    it('returns true when the bridge disconnects before the timeout', async () => {
+        const connection = createConnection();
+        const bridge = createBridge(connection);
+        const waitPromise = waitForBridgeDisconnectOrTimeout({
+            bridge,
+            connection,
+            timeoutMs: 50,
+        });
+        bridge.disconnect();
+        await expect(waitPromise).resolves.toBe(true);
+    });
+    it('returns false when the bridge stays connected through the timeout', async () => {
+        const connection = createConnection();
+        const bridge = createBridge(connection);
+        await expect(waitForBridgeDisconnectOrTimeout({
+            bridge,
+            connection,
+            timeoutMs: 10,
+        })).resolves.toBe(false);
+    });
+});
+describe('waitForStartupCrash', () => {
+    it('does not install a startup crash watch when native crash detection is disabled', async () => {
+        const watch = vi.fn();
+        const crashMonitor = {
+            watch,
+        };
+        const controller = new AbortController();
+        const waitPromise = waitForStartupCrash({
+            crashMonitor,
+            detectNativeCrashes: false,
+            testFilePath: '/test.harness.ts',
+            signal: controller.signal,
+        });
+        controller.abort(new DOMException('Aborted', 'AbortError'));
+        await expect(waitPromise).rejects.toThrow('Aborted');
+        expect(watch).not.toHaveBeenCalled();
+    });
+});

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