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

package/dist/execute-run.js

@@ -1,8 +1,9 @@
 import { randomUUID } from 'node:crypto';
 import path from 'node:path';
 import { runHarnessTestFile } from './run.js';
-import { NativeCrashError, StartupStallError, } from './errors.js';
-import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
+import { NativeCrashError, RuntimeDisconnectError, StartupStallError, } from './errors.js';
+import { AppBridgeDisconnectedError, DeviceNotRespondingError, } from '@react-native-harness/bridge/server';
+import { createPlatformSkippedTestResult, shouldRunHarnessTestFile, } from './test-file-platform-filter.js';
 const createRunSummary = () => ({ passed: 0, failed: 0, skipped: 0, todo: 0 });
 const applyJestResultToSummary = (summary, result) => {
     summary.passed += result.numPassingTests;
@@ -18,19 +19,62 @@ class CancelRun extends Error {
 }
 const buildTestFailure = (err) => {
     if (err instanceof NativeCrashError ||
+        err instanceof RuntimeDisconnectError ||
         err instanceof StartupStallError ||
+        err instanceof AppBridgeDisconnectedError ||
         err instanceof DeviceNotRespondingError) {
         return { message: err.message, stack: '' };
     }
     return err;
 };
-export const executeRun = async (session, tests, watcher, onStart, onResult, onFailure, globalConfig) => {
+const toJestMode = (declarationMode) => declarationMode;
+const emitHarnessTestStarted = async (emitEvent, event) => {
+    await emitEvent('test-case-start', event.file, {
+        ancestorTitles: event.ancestorTitles,
+        fullName: event.fullName,
+        mode: toJestMode(event.declarationMode),
+        title: event.name,
+        startedAt: event.startedAt,
+    });
+};
+const emitHarnessTestFinished = async (emitEvent, event) => {
+    const failureMessage = event.error?.message;
+    const codeFrame = event.error?.codeFrame;
+    const location = codeFrame?.location
+        ? { column: codeFrame.location.column, line: codeFrame.location.row }
+        : null;
+    const testCaseResult = {
+        ancestorTitles: event.ancestorTitles,
+        duration: event.duration,
+        failureDetails: [],
+        failureMessages: failureMessage
+            ? [`${failureMessage}${codeFrame ? `\n\n${codeFrame.content}` : ''}`]
+            : [],
+        fullName: event.fullName,
+        location,
+        numPassingAsserts: event.status === 'passed' ? 1 : 0,
+        startedAt: event.startedAt,
+        status: event.status,
+        title: event.name,
+    };
+    await emitEvent('test-case-result', event.file, testCaseResult);
+};
+const isHarnessCaseEvent = (event) => event.type === 'test-started' || event.type === 'test-finished';
+export const executeRun = async (session, tests, watcher, emitEvent, globalConfig) => {
     const runId = randomUUID();
     const startTime = Date.now();
     const watchMode = globalConfig.watch || globalConfig.watchAll;
     const rootDir = globalConfig.rootDir ?? process.cwd();
     const testFiles = tests.map((t) => path.relative(rootDir, t.path));
     const summary = createRunSummary();
+    let caseEventChain = Promise.resolve();
+    const unsubscribe = session.onTestRunnerEvent((event) => {
+        if (isHarnessCaseEvent(event)) {
+            caseEventChain = caseEventChain.then(() => event.type === 'test-started'
+                ? emitHarnessTestStarted(emitEvent, event)
+                : emitHarnessTestFinished(emitEvent, event));
+        }
+    });
     const updateRunState = (overrides = {}) => {
         const state = {
             runId,
@@ -59,6 +103,8 @@ export const executeRun = async (session, tests, watcher, onStart, onResult, onF
         host: session.config.host?.trim() || undefined,
     });
     const shouldResetEnv = session.config.resetEnvironmentBetweenTestFiles;
+    const platformId = session.context.platform.platformId;
+    const knownPlatformIds = new Set(session.config.runners.map((runner) => runner.platformId));
     let isFirstTest = true;
     let runError;
     try {
@@ -79,13 +125,39 @@ export const executeRun = async (session, tests, watcher, onStart, onResult, onF
                 });
             };
             await session.callHook('test-file:started', { runId, file: relativeTestPath });
+            if (!shouldRunHarnessTestFile(test.path, platformId, knownPlatformIds)) {
+                try {
+                    await emitEvent('test-file-start', test);
+                    const skippedResult = createPlatformSkippedTestResult(test.path);
+                    applyJestResultToSummary(summary, skippedResult);
+                    updateRunState();
+                    await emitTestFileFinished({
+                        status: 'skipped',
+                        duration: Date.now() - fileStartedAt,
+                        result: null,
+                    });
+                    await emitEvent('test-file-success', test, skippedResult);
+                }
+                catch (err) {
+                    if (!emittedTestFileFinished) {
+                        await emitTestFileFinished({
+                            status: 'failed',
+                            duration: Date.now() - fileStartedAt,
+                            result: null,
+                        });
+                    }
+                    updateRunState({ error: err });
+                    await emitEvent('test-file-failure', test, buildTestFailure(err));
+                }
+                continue;
+            }
             try {
                 if (shouldResetEnv && !isFirstTest) {
                     await session.restartApp(test.path);
                 }
                 isFirstTest = false;
                 session.flushClientLogs();
-                await onStart(test);
+                await emitEvent('test-file-start', test);
                 await session.ensureAppReady(test.path);
                 // Crash detection is handled inside session.runTestFile; NativeCrashError
                 // propagates here if a crash wins the race.
@@ -106,7 +178,8 @@ export const executeRun = async (session, tests, watcher, onStart, onResult, onF
                     duration: result.duration,
                     result: result.harnessResult,
                 });
-                await onResult(test, result.jestResult);
+                await caseEventChain;
+                await emitEvent('test-file-success', test, result.jestResult);
             }
             catch (err) {
                 if (!emittedTestFileFinished) {
@@ -117,17 +190,20 @@ export const executeRun = async (session, tests, watcher, onStart, onResult, onF
                     });
                 }
                 const isRuntimeFailure = err instanceof NativeCrashError ||
+                    err instanceof RuntimeDisconnectError ||
                     err instanceof StartupStallError ||
+                    err instanceof AppBridgeDisconnectedError ||
                     err instanceof DeviceNotRespondingError;
                 if (isRuntimeFailure) {
                     summary.failed += 1;
                     updateRunState();
                 }
-                if (err instanceof NativeCrashError) {
+                if (err instanceof NativeCrashError || err instanceof RuntimeDisconnectError) {
                     session.resetCrashState();
                 }
                 updateRunState({ error: isRuntimeFailure ? undefined : err });
-                onFailure(test, buildTestFailure(err));
+                await caseEventChain;
+                await emitEvent('test-file-failure', test, buildTestFailure(err));
             }
         }
     }
@@ -147,5 +223,7 @@ export const executeRun = async (session, tests, watcher, onStart, onResult, onF
             status: runState.status ?? (runError != null ? 'failed' : 'passed'),
             ...(runError != null ? { error: runError } : {}),
         });
+        await caseEventChain;
+        unsubscribe();
     }
 };

package/dist/harness-session.d.ts

@@ -1,10 +1,22 @@
-import { type HarnessContext, type TestExecutionOptions, type TestSuiteResult } from '@react-native-harness/bridge';
+import { type AppConnection } from '@react-native-harness/bridge/server';
+import { type HarnessContext, type TestRunnerEvents, type TestExecutionOptions, type TestSuiteResult } from '@react-native-harness/bridge';
 import { type HarnessPlatform } from '@react-native-harness/platforms';
 import { type HarnessPluginManager, type HarnessRunStatus, type HarnessRunSummary } from '@react-native-harness/plugins';
 import { type Config as HarnessConfig } from '@react-native-harness/config';
 import type { Config as JestConfig } from 'jest-runner';
+import { type CrashMonitor } from './crash-monitor.js';
 import { type ClientLogBuffer } from './client-log-handler.js';
 import { type ResourceLockManager } from './resource-lock.js';
+type DisconnectObservableBridge = {
+    readonly connection: AppConnection | null;
+    on: (event: 'disconnected', listener: () => void) => void;
+    off: (event: 'disconnected', listener: () => void) => void;
+};
+export declare const waitForBridgeDisconnectOrTimeout: ({ bridge, connection, timeoutMs, }: {
+    bridge: DisconnectObservableBridge;
+    connection: AppConnection;
+    timeoutMs: number;
+}) => Promise<boolean>;
 export type HarnessRunState = {
     readonly runId: string;
     readonly startTime: number;
@@ -19,6 +31,7 @@ export type HarnessRunTestsOptions = Exclude<TestExecutionOptions, 'platform'>;
 export type HarnessSession = {
     readonly config: HarnessConfig;
     readonly context: HarnessContext;
+    onTestRunnerEvent: (listener: (event: TestRunnerEvents) => void) => () => void;
     runTestFile: (path: string, options: HarnessRunTestsOptions) => Promise<TestSuiteResult>;
     ensureAppReady: (testFilePath: string) => Promise<void>;
     restartApp: (testFilePath?: string) => Promise<void>;
@@ -28,7 +41,14 @@ export type HarnessSession = {
     setRunState: (state: HarnessRunState | null) => void;
     dispose: (reason?: 'normal' | 'abort' | 'error') => Promise<void>;
 };
+export declare const waitForStartupCrash: ({ crashMonitor, detectNativeCrashes, testFilePath, signal, }: {
+    crashMonitor: CrashMonitor;
+    detectNativeCrashes: boolean;
+    testFilePath: string;
+    signal: AbortSignal;
+}) => Promise<never>;
 export declare const createHarnessSession: (globalConfig: JestConfig.GlobalConfig, { lockManager }?: {
     lockManager?: ResourceLockManager;
 }) => Promise<HarnessSession>;
+export {};
 //# sourceMappingURL=harness-session.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"harness-session.d.ts","sourceRoot":"","sources":["../src/harness-session.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,cAAc,EAEnB,KAAK,oBAAoB,EACzB,KAAK,eAAe,EACrB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAEL,KAAK,eAAe,EAGrB,MAAM,iCAAiC,CAAC;AASzC,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAOvC,OAAO,EAEL,KAAK,MAAM,IAAI,aAAa,EAE7B,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AAMxD,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAEL,KAAK,mBAAmB,EAEzB,MAAM,oBAAoB,CAAC;AAkB5B,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,oBAAoB,EAAE,UAAU,CAAC,CAAC;AAE/E,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IACjC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IACzF,cAAc,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,UAAU,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,eAAe,EAAE,MAAM,eAAe,CAAC;IACvC,QAAQ,EAAE,oBAAoB,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC,UAAU,CAAC,CAAC;IAC3E,WAAW,EAAE,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,KAAK,IAAI,CAAC;IACrD,OAAO,EAAE,CAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE,CAAC;AAuOF,eAAO,MAAM,oBAAoB,GAC/B,cAAc,UAAU,CAAC,YAAY,EACrC,kBAA8C;IAAE,WAAW,CAAC,EAAE,mBAAmB,CAAA;CAAO,KACvF,OAAO,CAAC,cAAc,CA6YxB,CAAC"}
+{"version":3,"file":"harness-session.d.ts","sourceRoot":"","sources":["../src/harness-session.ts"],"names":[],"mappings":"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"}

package/dist/harness-session.js

@@ -2,9 +2,10 @@ import { createHarnessBridge, } from '@react-native-harness/bridge/server';
 import { HARNESS_BRIDGE_PATH, } from '@react-native-harness/bridge';
 import { getMetroInstance, isMetroCacheReusable, waitForMetroBackedAppReady, } from '@react-native-harness/bundler-metro';
 import { createHarnessPluginManager, } from '@react-native-harness/plugins';
-import { logger, createCrashArtifactWriter, getTimeoutSignal, raceAbortSignals, } from '@react-native-harness/tools';
+import { createCrashArtifactWriter, logger, getTimeoutSignal, raceAbortSignals, } from '@react-native-harness/tools';
 import { getConfig, ConfigSchema, } from '@react-native-harness/config';
 import { preRunMessage } from 'jest-util';
+import path from 'node:path';
 import { PlatformReadyTimeoutError } from './errors.js';
 import { NoRunnerSpecifiedError, RunnerNotFoundError } from './errors.js';
 import { createCrashMonitor } from './crash-monitor.js';
@@ -18,6 +19,28 @@ import { logMetroCacheReused, logMetroPortFallback, logNativeCoverageCollected,
 const sessionLogger = logger.child('runtime');
 const defaultResourceLockManager = createResourceLockManager();
 const ignorePromiseRejection = () => undefined;
+const isBridgeDisconnectError = (error) => error instanceof Error && error.message === 'App bridge disconnected';
+const TEST_RUN_BRIDGE_STABILITY_WAIT_MS = 500;
+export const waitForBridgeDisconnectOrTimeout = async ({ bridge, connection, timeoutMs, }) => {
+    if (bridge.connection !== connection) {
+        return true;
+    }
+    return await new Promise((resolve) => {
+        const onDisconnected = () => {
+            cleanup();
+            resolve(true);
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            bridge.off('disconnected', onDisconnected);
+        };
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve(bridge.connection !== connection);
+        }, timeoutMs);
+        bridge.on('disconnected', onDisconnected);
+    });
+};
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -46,8 +69,21 @@ const withPlatformReadyTimeout = async (options) => {
         throw error;
     }
 };
+export const waitForStartupCrash = async ({ crashMonitor, detectNativeCrashes, testFilePath, signal, }) => {
+    if (!detectNativeCrashes) {
+        return await waitForAbort(signal);
+    }
+    const watch = crashMonitor.watch(testFilePath, 'startup');
+    watch.promise.catch(ignorePromiseRejection); // suppress unhandled-rejection when abort wins race
+    try {
+        return await Promise.race([watch.promise, waitForAbort(signal)]);
+    }
+    finally {
+        watch.cancel();
+    }
+};
 const waitForAppReady = async (base, testFilePath) => {
-    const { metroInstance, bridge, platformInstance, platformId, bundleStartTimeout, readyTimeout, maxAppRestarts, crashMonitor, appLaunchOptions, } = base;
+    const { metroInstance, bridge, platformId, bundleStartTimeout, readyTimeout, maxAppRestarts, crashMonitor, detectNativeCrashes, restartAppSession, } = base;
     const logWait = (message, ...args) => sessionLogger.debug(`waitForAppReady: ${message}`, ...args);
     return await waitForMetroBackedAppReady({
         metro: metroInstance,
@@ -58,7 +94,7 @@ const waitForAppReady = async (base, testFilePath) => {
         signal: new AbortController().signal,
         startAttempt: async () => {
             logWait('launching app for %s', testFilePath);
-            await platformInstance.restartApp(appLaunchOptions);
+            await restartAppSession();
             logWait('launch request completed, waiting for bridge ready');
         },
         waitForReady: async (signal) => {
@@ -69,7 +105,7 @@ const waitForAppReady = async (base, testFilePath) => {
             // connection from a previous run would resolve the promise before startAttempt
             // even restarts the app — leaving bridge.connection null after the restart.
             await new Promise((resolve, reject) => {
-                const onConnected = (_conn) => { cleanup(); resolve(); };
+                const onConnected = () => { cleanup(); resolve(); };
                 const onAbort = () => { cleanup(); reject(signal.reason ?? new DOMException('Aborted', 'AbortError')); };
                 const cleanup = () => {
                     bridge.off('connected', onConnected);
@@ -85,15 +121,13 @@ const waitForAppReady = async (base, testFilePath) => {
             logWait('runtime ready received');
         },
         waitForCrash: async (signal) => {
-            const watch = crashMonitor.watch(testFilePath, 'startup');
-            watch.promise.catch(ignorePromiseRejection); // suppress unhandled-rejection when abort wins race
-            try {
-                logWait('waiting for crash or runtime ready');
-                return await Promise.race([watch.promise, waitForAbort(signal)]);
-            }
-            finally {
-                watch.cancel();
-            }
+            logWait('waiting for crash or runtime ready');
+            return await waitForStartupCrash({
+                crashMonitor,
+                detectNativeCrashes,
+                testFilePath,
+                signal,
+            });
         },
         onAttemptStart: () => {
             logWait('beginning launch attempt for %s', testFilePath);
@@ -242,6 +276,11 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         const getCurrentRunId = () => currentRun?.runId;
         const clientLogCollector = createClientLogCollector();
         const context = { platform };
+        const crashArtifactWriter = createCrashArtifactWriter({
+            runnerName: platform.name,
+            platformId: platform.platformId,
+            rootDir: path.join(projectRoot, '.harness', 'crash-reports'),
+        });
         const bridge = await createHarnessBridge({
             noServer: true,
             timeout: runtimeConfig.bridgeTimeout,
@@ -268,6 +307,7 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
                     work: async (signal) => {
                         return await import(platform.runner).then((module) => module.default(platform.config, runtimeConfig, {
                             signal,
+                            crashArtifactWriter,
                         })).then((instance) => {
                             sessionLogger.debug('platform runner initialized');
                             return instance;
@@ -281,25 +321,38 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             await bridge.dispose();
             throw error;
         }
-        const crashArtifactWriter = createCrashArtifactWriter({
-            runnerName: platform.name,
-            platformId: platform.platformId,
-        });
-        const appMonitor = platformInstance.createAppMonitor({ crashArtifactWriter });
         const appLaunchOptions = platform.config.appLaunchOptions;
-        const crashMonitor = createCrashMonitor({ appMonitor, platformRunner: platformInstance });
+        let currentAppSession = null;
+        const crashMonitor = createCrashMonitor();
+        const disposeCurrentAppSession = async () => {
+            const session = currentAppSession;
+            currentAppSession = null;
+            crashMonitor.setAppSession(null);
+            if (session) {
+                await session.dispose();
+            }
+        };
+        const restartAppSession = async () => {
+            await crashMonitor.stop();
+            await disposeCurrentAppSession();
+            const session = await platformInstance.createAppSession(appLaunchOptions);
+            currentAppSession = session;
+            crashMonitor.setAppSession(session);
+            await crashMonitor.start();
+            return session;
+        };
         // Pre-build the options that are constant across all app-ready calls;
         // only testFilePath varies per call.
         const appReadyBaseOptions = {
             metroInstance,
             bridge,
-            platformInstance,
             platformId: platform.platformId,
             bundleStartTimeout: runtimeConfig.bundleStartTimeout ?? 60000,
             readyTimeout: runtimeConfig.bridgeTimeout,
             maxAppRestarts: runtimeConfig.maxAppRestarts ?? 2,
             crashMonitor,
-            appLaunchOptions,
+            detectNativeCrashes: runtimeConfig.detectNativeCrashes !== false,
+            restartAppSession,
         };
         // --- Event listeners ---
         const bridgeEventListener = buildBridgeHookScheduler(hooks, pluginManager, getCurrentRunId);
@@ -311,6 +364,17 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         };
         const flushClientLogs = () => clientLogCollector.flush();
         const clientLogListener = clientLogCollector.handleEvent;
+        const testRunnerEventListeners = new Set();
+        const onTestRunnerEvent = (event) => {
+            if (event.type === 'test-started' ||
+                event.type === 'test-finished' ||
+                event.type === 'suite-started' ||
+                event.type === 'suite-finished' ||
+                event.type === 'file-started' ||
+                event.type === 'file-finished') {
+                testRunnerEventListeners.forEach((listener) => listener(event));
+            }
+        };
         const onConnected = (conn) => {
             const runId = getCurrentRunId();
             if (!runId)
@@ -322,10 +386,14 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             if (!runId)
                 return;
             hooks.schedule(() => pluginManager.callHook('runtime:disconnected', { runId, reason: 'bridge-disconnected' }));
+            if (runtimeConfig.detectNativeCrashes !== false) {
+                crashMonitor.handleBridgeDisconnect();
+            }
         };
         bridge.on('connected', onConnected);
         bridge.on('disconnected', onDisconnected);
         bridge.on('event', bridgeEventListener);
+        bridge.on('event', onTestRunnerEvent);
         metroInstance.events.addListener(onMetroEvent);
         if (runtimeConfig.forwardClientLogs) {
             metroInstance.events.addListener(clientLogListener);
@@ -365,10 +433,12 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             bridge.off('connected', onConnected);
             bridge.off('disconnected', onDisconnected);
             bridge.off('event', bridgeEventListener);
+            bridge.off('event', onTestRunnerEvent);
             const nativeCoverageConfig = runtimeConfig.coverage?.native?.ios;
             if (nativeCoverageConfig?.pods?.length && platformInstance.collectNativeCoverage) {
                 try {
-                    await platformInstance.stopApp();
+                    await crashMonitor.stop();
+                    await disposeCurrentAppSession();
                     const lcovPath = await platformInstance.collectNativeCoverage({
                         pods: nativeCoverageConfig.pods,
                         outputDir: projectRoot,
@@ -385,6 +455,7 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             try {
                 await Promise.all([
                     crashMonitor.dispose(),
+                    disposeCurrentAppSession(),
                     bridge.dispose(),
                     platformInstance.dispose(),
                     metroInstance.dispose(),
@@ -419,8 +490,6 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         try {
             await pluginManager.callHook('harness:before-creation', { appLaunchOptions });
             await hooks.drain();
-            await appMonitor.start();
-            sessionLogger.debug('app monitor started');
             await pluginManager.callHook('harness:before-run', { appLaunchOptions });
             await hooks.drain();
         }
@@ -436,9 +505,12 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         const ensureAppReady = async (testFilePath) => {
             await hooks.drain();
             sessionLogger.debug('ensuring app is ready for %s', testFilePath);
-            if (crashMonitor.isAlive() && bridge.connection !== null && await platformInstance.isAppRunning()) {
-                sessionLogger.debug('reusing existing ready app for %s', testFilePath);
-                return;
+            if (crashMonitor.isAlive() && bridge.connection !== null && currentAppSession) {
+                const state = await currentAppSession.getState();
+                if (state.status === 'running') {
+                    sessionLogger.debug('reusing existing ready app for %s', testFilePath);
+                    return;
+                }
             }
             crashMonitor.reset();
             sessionLogger.debug('app not ready, waiting for launch and runtime readiness');
@@ -450,16 +522,16 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             await hooks.drain();
             await crashMonitor.stop();
             sessionLogger.debug('restarting app (testFile=%s mode=%s)', testFilePath ?? 'n/a', testFilePath ? 'stop-and-ensure-ready' : 'direct-restart');
+            await disposeCurrentAppSession();
             if (testFilePath) {
-                await platformInstance.stopApp();
+                await ensureAppReady(testFilePath);
             }
             else {
-                await platformInstance.restartApp(appLaunchOptions);
-            }
-            crashMonitor.reset();
-            await crashMonitor.start();
-            if (testFilePath) {
-                await ensureAppReady(testFilePath);
+                const session = await platformInstance.createAppSession(appLaunchOptions);
+                currentAppSession = session;
+                crashMonitor.setAppSession(session);
+                crashMonitor.reset();
+                await crashMonitor.start();
             }
             await hooks.drain();
             sessionLogger.debug('restart completed');
@@ -470,7 +542,7 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             if (!conn)
                 throw new Error('No active app connection');
             sessionLogger.debug('running test file on client: %s', testPath);
-            if (!runtimeConfig.detectNativeCrashes) {
+            if (runtimeConfig.detectNativeCrashes === false) {
                 const result = await conn.runTests(testPath, { ...options, runner: platform.runner });
                 await hooks.drain();
                 return result;
@@ -480,13 +552,30 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             // crash wins the race or cancel() is called after the test run wins.
             crashWatch.promise.catch(ignorePromiseRejection);
             try {
-                const result = await Promise.race([
-                    conn.runTests(testPath, { ...options, runner: platform.runner }),
-                    crashWatch.promise,
-                ]);
+                const testRunPromise = conn.runTests(testPath, {
+                    ...options,
+                    runner: platform.runner,
+                });
+                const result = await Promise.race([testRunPromise, crashWatch.promise]);
+                const bridgeDisconnected = await waitForBridgeDisconnectOrTimeout({
+                    bridge,
+                    connection: conn,
+                    timeoutMs: TEST_RUN_BRIDGE_STABILITY_WAIT_MS,
+                });
+                if (bridgeDisconnected) {
+                    return await crashWatch.promise;
+                }
                 await hooks.drain();
                 return result;
             }
+            catch (error) {
+                if (isBridgeDisconnectError(error)) {
+                    const result = await crashWatch.promise;
+                    await hooks.drain();
+                    return result;
+                }
+                throw error;
+            }
             finally {
                 crashWatch.cancel();
             }
@@ -494,6 +583,12 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         return {
             config: runtimeConfig,
             context,
+            onTestRunnerEvent: (listener) => {
+                testRunnerEventListeners.add(listener);
+                return () => {
+                    testRunnerEventListeners.delete(listener);
+                };
+            },
             runTestFile,
             ensureAppReady,
             restartApp,

package/dist/index.d.ts

@@ -1,8 +1,12 @@
-import type { CallbackTestRunnerInterface, Config, OnTestFailure, OnTestStart, OnTestSuccess, Test, TestRunnerOptions, TestWatcher } from 'jest-runner';
-export default class JestHarness implements CallbackTestRunnerInterface {
+import type { Config, EmittingTestRunnerInterface, Test, TestEvents, TestRunnerOptions, TestWatcher } from 'jest-runner';
+type TestEventListener<Name extends keyof TestEvents> = (eventData: TestEvents[Name]) => void | Promise<void>;
+export default class JestHarness implements EmittingTestRunnerInterface {
     #private;
     readonly isSerial = true;
+    readonly supportsEventEmitters: true;
     constructor(globalConfig: Config.GlobalConfig);
-    runTests(tests: Array<Test>, watcher: TestWatcher, onStart: OnTestStart, onResult: OnTestSuccess, onFailure: OnTestFailure, options: TestRunnerOptions): Promise<void>;
+    on<Name extends keyof TestEvents>(eventName: Name, listener: TestEventListener<Name>): () => void;
+    runTests(tests: Array<Test>, watcher: TestWatcher, options: TestRunnerOptions): Promise<void>;
 }
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,MAAM,EACN,aAAa,EACb,WAAW,EACX,aAAa,EACb,IAAI,EACJ,iBAAiB,EACjB,WAAW,EACZ,MAAM,aAAa,CAAC;AAMrB,MAAM,CAAC,OAAO,OAAO,WAAY,YAAW,2BAA2B;;IACrE,QAAQ,CAAC,QAAQ,QAAQ;gBAKb,YAAY,EAAE,MAAM,CAAC,YAAY;IAIvC,QAAQ,CACZ,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC;CAiCjB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EACN,2BAA2B,EAC3B,IAAI,EACJ,UAAU,EACV,iBAAiB,EACjB,WAAW,EACZ,MAAM,aAAa,CAAC;AAMrB,KAAK,iBAAiB,CAAC,IAAI,SAAS,MAAM,UAAU,IAAI,CACtD,SAAS,EAAE,UAAU,CAAC,IAAI,CAAC,KACxB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE1B,MAAM,CAAC,OAAO,OAAO,WAAY,YAAW,2BAA2B;;IACrE,QAAQ,CAAC,QAAQ,QAAQ;IACzB,QAAQ,CAAC,qBAAqB,EAAG,IAAI,CAAU;gBAMnC,YAAY,EAAE,MAAM,CAAC,YAAY;IAI7C,EAAE,CAAC,IAAI,SAAS,MAAM,UAAU,EAC9B,SAAS,EAAE,IAAI,EACf,QAAQ,EAAE,iBAAiB,CAAC,IAAI,CAAC,GAChC,MAAM,IAAI;IAaP,QAAQ,CACZ,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC;CA6CjB"}

package/dist/index.js

@@ -4,12 +4,25 @@ import { HarnessError } from '@react-native-harness/tools';
 import { getErrorMessage } from './logs.js';
 export default class JestHarness {
     isSerial = true;
+    supportsEventEmitters = true;
     #globalConfig;
     #session = null;
+    #listeners = new Map();
     constructor(globalConfig) {
         this.#globalConfig = globalConfig;
     }
-    async runTests(tests, watcher, onStart, onResult, onFailure, options) {
+    on(eventName, listener) {
+        const listeners = this.#listeners.get(eventName) ?? new Set();
+        listeners.add(listener);
+        this.#listeners.set(eventName, listeners);
+        return () => {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.#listeners.delete(eventName);
+            }
+        };
+    }
+    async runTests(tests, watcher, options) {
         if (!options.serial) {
             throw new Error('Parallel test running is not supported');
         }
@@ -18,7 +31,7 @@ export default class JestHarness {
             if (!this.#session) {
                 this.#session = await createHarnessSession(this.#globalConfig);
             }
-            await executeRun(this.#session, tests, watcher, onStart, onResult, onFailure, this.#globalConfig);
+            await executeRun(this.#session, tests, watcher, this.#emit, this.#globalConfig);
         }
         catch (error) {
             if (error instanceof HarnessError) {
@@ -33,4 +46,13 @@ export default class JestHarness {
             }
         }
     }
+    #emit = async (eventName, ...eventData) => {
+        const listeners = this.#listeners.get(eventName);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            await listener(eventData);
+        }
+    };
 }

package/dist/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,IAAI,sBAAsB,EAE1C,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAuD3D,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,cAAc,CAAC;IACxB,aAAa,EAAE,UAAU,CAAC,aAAa,CAAC;IACxC,YAAY,EAAE,UAAU,CAAC,YAAY,CAAC;CACvC,KAAK,OAAO,CAAC;IACZ,UAAU,EAAE,cAAc,CAAC;IAC3B,aAAa,EAAE,sBAAsB,CAAC;IACtC,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,kBAkFhC,CAAC"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,IAAI,sBAAsB,EAE1C,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAuD3D,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,cAAc,CAAC;IACxB,aAAa,EAAE,UAAU,CAAC,aAAa,CAAC;IACxC,YAAY,EAAE,UAAU,CAAC,YAAY,CAAC;CACvC,KAAK,OAAO,CAAC;IACZ,UAAU,EAAE,cAAc,CAAC;IAC3B,aAAa,EAAE,sBAAsB,CAAC;IACtC,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,kBAmFhC,CAAC"}

package/dist/run.js

@@ -67,6 +67,7 @@ export const runHarnessTestFile = async ({ testPath, globalConfig, projectConfig
                 ? `${errorMessage}${codeFrame ? `\n\n${codeFrame.content}` : ''}`
                 : undefined,
             title: test.name,
+            fullName: test.fullName,
             status: test.status,
             location: codeFrame?.location
                 ? { column: codeFrame.location.column, line: codeFrame.location.row }

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

@@ -0,0 +1,5 @@
+import type { TestResult as JestTestResult } from '@jest/test-result';
+export declare const getHarnessTestFilePlatform: (testPath: string, knownPlatformIds: ReadonlySet<string>) => string | null;
+export declare const shouldRunHarnessTestFile: (testPath: string, platformId: string, knownPlatformIds: ReadonlySet<string>) => boolean;
+export declare const createPlatformSkippedTestResult: (testPath: string) => JestTestResult;
+//# sourceMappingURL=test-file-platform-filter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test-file-platform-filter.d.ts","sourceRoot":"","sources":["../src/test-file-platform-filter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAMtE,eAAO,MAAM,0BAA0B,GACrC,UAAU,MAAM,EAChB,kBAAkB,WAAW,CAAC,MAAM,CAAC,KACpC,MAAM,GAAG,IAQX,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,UAAU,MAAM,EAChB,YAAY,MAAM,EAClB,kBAAkB,WAAW,CAAC,MAAM,CAAC,KACpC,OAGF,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAC1C,UAAU,MAAM,KACf,cAyBF,CAAC"}