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

package/dist/harness-session.js

@@ -1,18 +1,21 @@
-import { createHarnessBridge, } from '@react-native-harness/bridge/server';
+import { createHarnessBridge, AppBridgeDisconnectedError, } 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 { createHarnessCache } from '@react-native-harness/cache';
+import { getMetroInstance, waitForMetroBackedAppReady, } from '@react-native-harness/bundler-metro';
 import { createHarnessPluginManager, } from '@react-native-harness/plugins';
-import { createCrashArtifactWriter, logger, getTimeoutSignal, raceAbortSignals, } from '@react-native-harness/tools';
-import { getConfig, ConfigSchema, } from '@react-native-harness/config';
+import { createCrashArtifactWriter, createDiagnostics, logger, getTimeoutSignal, ensureSignalsDeliverable, waitForAbort, } from '@react-native-harness/tools';
+import { getConfig, isDiagnosticsEnabled, resolveMetroCacheEnabled, 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';
+import { createProcessResetStrategy, createRuntimeResetStrategy, resolveResetStrategyKind, withEscalation, } from './environment-reset.js';
 import { createHookQueue } from './hook-queue.js';
 import { createClientLogCollector, } from './client-log-handler.js';
 import { createActionHooksPlugin } from './action-hooks.js';
 import { createResourceLockManager, } from './resource-lock.js';
+import { observeBridgeEvents, observeMetroEvents } from './diagnostics/index.js';
 import { resolveHarnessMetroPort } from './metro-port.js';
 import { getAdditionalCliArgs } from './cli-args.js';
 import { logMetroCacheReused, logMetroPortFallback, logNativeCoverageCollected, logRunnerStarting, logRunnerStillWaitingInQueue, logRunnerWaitingInQueue, logTestEnvironmentReady, logTestRunHeader, } from './logs.js';
@@ -41,45 +44,69 @@ export const waitForBridgeDisconnectOrTimeout = async ({ bridge, connection, tim
         bridge.on('disconnected', onDisconnected);
     });
 };
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-const createAbortError = () => new DOMException('The operation was aborted', 'AbortError');
-const waitForAbort = (signal) => {
+// Resolves the NEXT time the bridge reports a 'connected' event, rejecting
+// if `signal` aborts first. Deliberately does not use bridge.nextConnection(),
+// which would resolve immediately for a stale, already-set connection.
+export const waitForNextConnected = ({ bridge, signal, }) => new Promise((resolve, reject) => {
+    const onConnected = () => { cleanup(); resolve(); };
+    const onAbort = () => { cleanup(); reject(signal.reason ?? new DOMException('Aborted', 'AbortError')); };
+    const cleanup = () => {
+        bridge.off('connected', onConnected);
+        signal.removeEventListener('abort', onAbort);
+    };
     if (signal.aborted) {
-        return Promise.reject(signal.reason ?? createAbortError());
+        onAbort();
+        return;
     }
-    return new Promise((_, reject) => {
-        signal.addEventListener('abort', () => reject(signal.reason ?? createAbortError()), { once: true });
-    });
+    bridge.on('connected', onConnected);
+    signal.addEventListener('abort', onAbort, { once: true });
+});
+export const getSignalExitCodeForRunState = (state) => {
+    if (state?.completed &&
+        state.status === 'passed' &&
+        !state.error &&
+        (state.summary?.failed ?? 0) === 0) {
+        return 0;
+    }
+    return 1;
 };
-const withPlatformReadyTimeout = async (options) => {
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+// Bounds only the init *call* with a readiness timeout; `options.signal` (the
+// session-lifetime signal) is passed to `work` unmodified, so a slow init
+// call keeps observing real session teardown, not a synthetic timeout abort.
+// On timeout this throws PlatformReadyTimeoutError without cancelling `work`
+// itself — the caller is expected to abort the session signal as part of
+// tearing down, which then cancels the still-inflight call cooperatively.
+export const withPlatformReadyTimeout = async (options) => {
     const timeoutSignal = getTimeoutSignal(options.timeout);
-    const combinedSignal = raceAbortSignals([options.signal, timeoutSignal]);
+    const abortWait = waitForAbort(timeoutSignal);
     try {
-        return await options.work(combinedSignal);
+        return await Promise.race([
+            options.work(options.signal),
+            abortWait.promise.catch(() => {
+                throw new PlatformReadyTimeoutError(options.timeout);
+            }),
+        ]);
     }
-    catch (error) {
-        if (error instanceof DOMException &&
-            error.name === 'AbortError' &&
-            timeoutSignal.aborted &&
-            !options.signal.aborted) {
-            throw new PlatformReadyTimeoutError(options.timeout);
-        }
-        throw error;
+    finally {
+        abortWait.cancel();
     }
 };
 export const waitForStartupCrash = async ({ crashMonitor, detectNativeCrashes, testFilePath, signal, }) => {
     if (!detectNativeCrashes) {
-        return await waitForAbort(signal);
+        return await waitForAbort(signal).promise;
     }
     const watch = crashMonitor.watch(testFilePath, 'startup');
     watch.promise.catch(ignorePromiseRejection); // suppress unhandled-rejection when abort wins race
+    const abortWait = waitForAbort(signal);
     try {
-        return await Promise.race([watch.promise, waitForAbort(signal)]);
+        return await Promise.race([watch.promise, abortWait.promise]);
     }
     finally {
         watch.cancel();
+        abortWait.cancel();
     }
 };
 const waitForAppReady = async (base, testFilePath) => {
@@ -104,20 +131,7 @@ const waitForAppReady = async (base, testFilePath) => {
             // is already set. waitForReady is called before startAttempt, so a stale
             // 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 = () => { cleanup(); resolve(); };
-                const onAbort = () => { cleanup(); reject(signal.reason ?? new DOMException('Aborted', 'AbortError')); };
-                const cleanup = () => {
-                    bridge.off('connected', onConnected);
-                    signal.removeEventListener('abort', onAbort);
-                };
-                if (signal.aborted) {
-                    onAbort();
-                    return;
-                }
-                bridge.on('connected', onConnected);
-                signal.addEventListener('abort', onAbort, { once: true });
-            });
+            await waitForNextConnected({ bridge, signal });
             logWait('runtime ready received');
         },
         waitForCrash: async (signal) => {
@@ -184,9 +198,23 @@ const applyEnvVars = (harnessConfig, globalConfig) => {
         process.env.RN_HARNESS_VIEW_FLATTENING = 'false';
     }
 };
+/**
+ * Logs the "Reusing Metro cache" message when persistent Metro caching is
+ * enabled and the cache is warm. `projectRoot` must be the config-resolved
+ * project root so the warmth check looks at the same directory Metro caches
+ * into.
+ */
+export const maybeLogMetroCacheReused = (options) => {
+    if (!resolveMetroCacheEnabled(options.config)) {
+        return;
+    }
+    if (createHarnessCache({ projectRoot: options.projectRoot }).isWarm('metro')) {
+        logMetroCacheReused(options.platform);
+    }
+};
 const loadConfig = async (globalConfig) => {
     const projectRoot = globalConfig.rootDir;
-    const { config: rawConfig } = await getConfig(projectRoot);
+    const { config: rawConfig, projectRoot: configProjectRoot } = await getConfig(projectRoot);
     const cliArgs = getAdditionalCliArgs();
     let harnessConfig = cliArgs.metroPort != null
         ? ConfigSchema.parse({ ...rawConfig, metroPort: cliArgs.metroPort })
@@ -207,29 +235,40 @@ const loadConfig = async (globalConfig) => {
     const platform = harnessConfig.runners.find((r) => r.name === selectedRunnerName);
     if (!platform)
         throw new RunnerNotFoundError(selectedRunnerName);
-    return { harnessConfig, platform, projectRoot };
+    return { harnessConfig, platform, projectRoot, configProjectRoot };
 };
 // ---------------------------------------------------------------------------
 // Session creation
 // ---------------------------------------------------------------------------
 export const createHarnessSession = async (globalConfig, { lockManager = defaultResourceLockManager } = {}) => {
     preRunMessage.remove(process.stderr);
-    const { harnessConfig, platform, projectRoot } = await loadConfig(globalConfig);
+    const setupStartedAt = Date.now();
+    const { harnessConfig, platform, projectRoot, configProjectRoot } = await loadConfig(globalConfig);
     applyEnvVars(harnessConfig, globalConfig);
+    const diagnostics = createDiagnostics({
+        enabled: isDiagnosticsEnabled(harnessConfig),
+    });
+    diagnostics.record({
+        label: 'session.config.load',
+        duration: Date.now() - setupStartedAt,
+    });
     sessionLogger.debug('creating session for runner=%s platform=%s', platform.name, platform.platformId);
-    // Single AbortController for the entire setup phase. Registered signal
-    // handlers abort this so that slow inflight operations (Metro init, platform
-    // runner startup) are cancelled promptly on SIGTERM/SIGINT.
-    const setupController = new AbortController();
-    const onEarlySignal = () => setupController.abort();
+    // Single, session-lifetime AbortController: it aborts on early SIGTERM/SIGINT
+    // during setup (below) and, once the session is up, in dispose()'s finally
+    // (unchanged lifetime). It is the one signal the plugin manager and platform
+    // runner see for the entire session, so its abort reaches every long-lived
+    // child the runner threads it into.
+    ensureSignalsDeliverable();
+    const sessionController = new AbortController();
+    const onEarlySignal = () => sessionController.abort();
     process.once('SIGTERM', onEarlySignal);
     process.once('SIGINT', onEarlySignal);
     const resourceLockKey = await (platform.getResourceLockKey?.() ?? getDefaultResourceLockKey(platform));
     let didWaitForResourceLock = false;
     let lastStillWaitingLogAt = 0;
     logTestRunHeader(platform);
-    const resourceLease = await lockManager.acquire(resourceLockKey, {
-        signal: setupController.signal,
+    const resourceLease = await diagnostics.measure('session.lock.wait', () => lockManager.acquire(resourceLockKey, {
+        signal: sessionController.signal,
         onWait: () => {
             didWaitForResourceLock = true;
             logRunnerWaitingInQueue(platform);
@@ -242,7 +281,7 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             logRunnerStillWaitingInQueue(platform);
             sessionLogger.debug('still waiting in queue for runner=%s key=%s elapsedMs=%d', platform.name, resourceLockKey, elapsedMs);
         },
-    });
+    }), { lockKey: resourceLockKey });
     if (didWaitForResourceLock)
         logRunnerStarting(platform);
     sessionLogger.debug('resource lock acquired for runner=%s key=%s', platform.name, resourceLockKey);
@@ -250,26 +289,39 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
     // port resolution but before the inner try/catch (e.g. bridge creation failure).
     let metroPortLease = null;
     try {
-        const resolution = await resolveHarnessMetroPort({
-            config: harnessConfig,
-            platform,
-            resourceLockManager: lockManager,
-            signal: setupController.signal,
+        const portResolveSpan = diagnostics.start('session.port.resolve');
+        let resolution;
+        try {
+            resolution = await resolveHarnessMetroPort({
+                config: harnessConfig,
+                platform,
+                resourceLockManager: lockManager,
+                signal: sessionController.signal,
+            });
+        }
+        catch (error) {
+            portResolveSpan.fail(error);
+            throw error;
+        }
+        portResolveSpan.end({
+            port: resolution.config.metroPort,
+            didFallback: resolution.didFallback,
         });
         metroPortLease = resolution.metroPortLease;
         const { config: runtimeConfig, initialMetroPort, didFallback } = resolution;
         if (didFallback)
             logMetroPortFallback(initialMetroPort, runtimeConfig.metroPort);
-        if (runtimeConfig.unstable__enableMetroCache && isMetroCacheReusable(projectRoot)) {
-            logMetroCacheReused(platform);
-        }
-        const pluginAbortController = new AbortController();
+        maybeLogMetroCacheReused({
+            config: runtimeConfig,
+            projectRoot: configProjectRoot,
+            platform,
+        });
         const pluginManager = createHarnessPluginManager({
             plugins: (runtimeConfig.plugins ?? []),
             projectRoot,
             config: runtimeConfig,
             runner: platform,
-            abortSignal: pluginAbortController.signal,
+            abortSignal: sessionController.signal,
         });
         const hooks = createHookQueue();
         let currentRun = null;
@@ -281,43 +333,68 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             platformId: platform.platformId,
             rootDir: path.join(projectRoot, '.harness', 'crash-reports'),
         });
-        const bridge = await createHarnessBridge({
+        const bridge = await diagnostics.measure('session.bridge.init', () => createHarnessBridge({
             noServer: true,
             timeout: runtimeConfig.bridgeTimeout,
             context,
-        });
+        }));
         sessionLogger.debug('bridge initialized on Metro websocket path %s', HARNESS_BRIDGE_PATH);
         let metroInstance;
         let platformInstance;
+        // Noop until the Metro instance resolves and the deriver is attached.
+        let disposeMetroDiagnostics = () => undefined;
         try {
             [metroInstance, platformInstance] = await Promise.all([
-                getMetroInstance({
+                diagnostics.measure('metro.init', () => getMetroInstance({
                     projectRoot,
                     harnessConfig: runtimeConfig,
                     websocketEndpoints: {
                         [HARNESS_BRIDGE_PATH]: bridge.ws,
                     },
-                }, setupController.signal).then((instance) => {
+                    watchMode: globalConfig.watch || globalConfig.watchAll,
+                }, sessionController.signal).then((instance) => {
                     sessionLogger.debug('Metro initialized');
+                    // Attach the Metro diagnostics deriver before the eager prewarm
+                    // fires so its bundle build/request events land in the trace.
+                    disposeMetroDiagnostics = observeMetroEvents(instance.events, diagnostics);
+                    if (runtimeConfig.eagerPrewarm !== false) {
+                        // Kick off the first bundle build while the platform is still booting.
+                        // prewarm() memoizes this first call, so its session-lifetime setup
+                        // signal is the one that matters — later callers' signals cannot
+                        // cancel it. Not awaited: metro.init must resolve immediately.
+                        const prewarmSpan = diagnostics.start('metro.prewarm');
+                        instance
+                            .prewarm({
+                            platform: platform.platformId,
+                            signal: sessionController.signal,
+                        })
+                            .then((completed) => prewarmSpan.end({ completed }))
+                            // Swallow AbortError on teardown so it never becomes an
+                            // unhandled rejection; non-abort failures resolve false.
+                            .catch((error) => prewarmSpan.fail(error));
+                    }
                     return instance;
-                }),
-                withPlatformReadyTimeout({
+                })),
+                diagnostics.measure('platform.init', () => withPlatformReadyTimeout({
                     timeout: runtimeConfig.platformReadyTimeout,
-                    signal: setupController.signal,
+                    signal: sessionController.signal,
                     work: async (signal) => {
                         return await import(platform.runner).then((module) => module.default(platform.config, runtimeConfig, {
                             signal,
                             crashArtifactWriter,
+                            diagnostics,
                         })).then((instance) => {
                             sessionLogger.debug('platform runner initialized');
                             return instance;
                         });
                     },
-                }),
+                }), { runner: platform.runner, platformId: platform.platformId }),
             ]);
         }
         catch (error) {
-            // Only bridge needs cleanup here; leases are released by the outer catch.
+            // Only bridge and the Metro diagnostics listener need cleanup here;
+            // leases are released by the outer catch.
+            disposeMetroDiagnostics();
             await bridge.dispose();
             throw error;
         }
@@ -335,7 +412,7 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         const restartAppSession = async () => {
             await crashMonitor.stop();
             await disposeCurrentAppSession();
-            const session = await platformInstance.createAppSession(appLaunchOptions);
+            const session = await diagnostics.measure('app.session.create', () => platformInstance.createAppSession(appLaunchOptions));
             currentAppSession = session;
             crashMonitor.setAppSession(session);
             await crashMonitor.start();
@@ -398,11 +475,13 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         if (runtimeConfig.forwardClientLogs) {
             metroInstance.events.addListener(clientLogListener);
         }
+        const disposeBridgeDiagnostics = observeBridgeEvents(bridge, diagnostics);
         sessionLogger.debug('registered runtime, bridge, and Metro listeners');
         // --- Dispose ---
         let disposePromise = null;
         const disposeOnce = async (reason) => {
             sessionLogger.debug('disposing session (reason=%s)', reason);
+            const disposeSpan = diagnostics.start('dispose.total', { reason });
             let hookError;
             try {
                 await hooks.drain();
@@ -434,6 +513,8 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             bridge.off('disconnected', onDisconnected);
             bridge.off('event', bridgeEventListener);
             bridge.off('event', onTestRunnerEvent);
+            disposeMetroDiagnostics();
+            disposeBridgeDiagnostics();
             const nativeCoverageConfig = runtimeConfig.coverage?.native?.ios;
             if (nativeCoverageConfig?.pods?.length && platformInstance.collectNativeCoverage) {
                 try {
@@ -453,9 +534,13 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             }
             let cleanupError;
             try {
+                // The app session (and its logcat/device log stream) must be fully
+                // torn down before the platform is disposed: platform disposal can
+                // shut down the device/emulator, and doing that concurrently with
+                // the app session's own cleanup races the device's log stream
+                // against the device disappearing out from under it.
+                await Promise.all([crashMonitor.dispose(), disposeCurrentAppSession()]);
                 await Promise.all([
-                    crashMonitor.dispose(),
-                    disposeCurrentAppSession(),
                     bridge.dispose(),
                     platformInstance.dispose(),
                     metroInstance.dispose(),
@@ -467,13 +552,18 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             }
             finally {
                 await resourceLease.release();
-                pluginAbortController.abort();
+                sessionController.abort();
             }
             sessionLogger.debug('session resources disposed');
-            if (hookError)
+            if (hookError) {
+                disposeSpan.fail(hookError);
                 throw hookError;
-            if (cleanupError)
+            }
+            if (cleanupError) {
+                disposeSpan.fail(cleanupError);
                 throw cleanupError;
+            }
+            disposeSpan.end();
         };
         const dispose = (reason = 'normal') => {
             disposePromise ??= disposeOnce(reason);
@@ -483,7 +573,10 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         // that all infrastructure is up.
         process.off('SIGTERM', onEarlySignal);
         process.off('SIGINT', onEarlySignal);
-        const onSignal = () => void dispose('abort').then(() => process.exit(0));
+        const onSignal = () => {
+            const exitCode = getSignalExitCodeForRunState(currentRun);
+            void dispose('abort').then(() => process.exit(exitCode), () => process.exit(1));
+        };
         process.once('SIGTERM', onSignal);
         process.once('SIGINT', onSignal);
         // --- Startup hooks ---
@@ -500,28 +593,42 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             throw error;
         }
         logTestEnvironmentReady(platform);
+        diagnostics.record({
+            label: 'session.setup',
+            duration: Date.now() - setupStartedAt,
+        });
         sessionLogger.debug('session ready');
         // --- Public API ---
         const ensureAppReady = async (testFilePath) => {
             await hooks.drain();
             sessionLogger.debug('ensuring app is ready for %s', testFilePath);
+            const appReadySpan = diagnostics.start('app.ready.total');
             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);
+                    appReadySpan.end({ file: testFilePath, reused: true });
                     return;
                 }
             }
             crashMonitor.reset();
             sessionLogger.debug('app not ready, waiting for launch and runtime readiness');
-            await waitForAppReady(appReadyBaseOptions, testFilePath);
+            try {
+                await waitForAppReady(appReadyBaseOptions, testFilePath);
+            }
+            catch (error) {
+                appReadySpan.fail(error, { file: testFilePath, reused: false });
+                throw error;
+            }
             await hooks.drain();
             sessionLogger.debug('app is ready for %s', testFilePath);
+            appReadySpan.end({ file: testFilePath, reused: false });
         };
-        const restartApp = async (testFilePath) => {
-            await hooks.drain();
+        // Shared by restartApp (crash/timeout recovery) and the 'process' reset
+        // strategy: kill the current app session and either wait for a fresh one
+        // to become ready for testFilePath, or (no testFilePath) just launch one.
+        const performRestart = async (testFilePath) => {
             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 ensureAppReady(testFilePath);
@@ -533,8 +640,65 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
                 crashMonitor.reset();
                 await crashMonitor.start();
             }
+        };
+        const restartApp = async (testFilePath) => {
+            await hooks.drain();
+            const reason = testFilePath
+                ? 'stop-and-ensure-ready'
+                : 'direct-restart';
+            sessionLogger.debug('restarting app (testFile=%s mode=%s)', testFilePath ?? 'n/a', reason);
+            const restartSpan = diagnostics.start('app.restart', { reason });
+            try {
+                await performRestart(testFilePath);
+                await hooks.drain();
+                sessionLogger.debug('restart completed');
+                restartSpan.end();
+            }
+            catch (error) {
+                restartSpan.fail(error);
+                throw error;
+            }
+        };
+        const processResetStrategy = createProcessResetStrategy({
+            restart: performRestart,
+        });
+        const runtimeResetStrategy = createRuntimeResetStrategy({
+            getConnection: () => bridge.connection,
+            expectDisconnect: crashMonitor.expectDisconnect,
+            waitForReconnect: (signal) => waitForNextConnected({ bridge, signal }),
+            // Pending rpc.invoke calls reject with AppBridgeDisconnectedError when
+            // the app connection drops (see bridge server's disconnect()).
+            isDisconnectError: (error) => error instanceof AppBridgeDisconnectedError,
+            timeoutMs: runtimeConfig.bundleStartTimeout ?? 60000,
+        });
+        const resetEnvironment = async (testFilePath) => {
+            const requestedKind = resolveResetStrategyKind(runtimeConfig.resetEnvironmentBetweenTestFiles);
+            if (requestedKind === null) {
+                return;
+            }
             await hooks.drain();
-            sessionLogger.debug('restart completed');
+            sessionLogger.debug('resetting environment (testFile=%s kind=%s)', testFilePath, requestedKind);
+            let escalated = false;
+            const strategy = requestedKind === 'runtime'
+                ? withEscalation(runtimeResetStrategy, processResetStrategy, {
+                    onEscalate: (error) => {
+                        escalated = true;
+                        sessionLogger.debug('runtime reset failed, escalating to process restart: %s', error);
+                    },
+                })
+                : processResetStrategy;
+            const resetSpan = diagnostics.start('app.reset', { requested: requestedKind });
+            const performed = () => (escalated ? 'process' : requestedKind);
+            try {
+                await strategy.reset({ testFilePath });
+                await hooks.drain();
+                sessionLogger.debug('environment reset completed');
+                resetSpan.end({ performed: performed(), escalated });
+            }
+            catch (error) {
+                resetSpan.fail(error, { performed: performed(), escalated });
+                throw error;
+            }
         };
         const runTestFile = async (testPath, options) => {
             await hooks.drain();
@@ -583,6 +747,7 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
         return {
             config: runtimeConfig,
             context,
+            diagnostics,
             onTestRunnerEvent: (listener) => {
                 testRunnerEventListeners.add(listener);
                 return () => {
@@ -592,26 +757,34 @@ export const createHarnessSession = async (globalConfig, { lockManager = default
             runTestFile,
             ensureAppReady,
             restartApp,
+            resetEnvironment,
             resetCrashState: () => crashMonitor.reset(),
             flushClientLogs,
             callHook: async (name, payload) => {
                 await hooks.drain();
-                await pluginManager.callHook(name, payload);
+                await diagnostics.measure('plugin.hook', () => pluginManager.callHook(name, payload), { hook: String(name) });
                 await hooks.drain();
             },
             setRunState: (state) => {
                 currentRun = state;
             },
-            dispose: (reason = 'normal') => {
-                process.off('SIGTERM', onSignal);
-                process.off('SIGINT', onSignal);
-                return dispose(reason);
+            dispose: async (reason = 'normal') => {
+                try {
+                    await dispose(reason);
+                }
+                finally {
+                    process.off('SIGTERM', onSignal);
+                    process.off('SIGINT', onSignal);
+                }
             },
         };
     }
     catch (error) {
         process.off('SIGTERM', onEarlySignal);
         process.off('SIGINT', onEarlySignal);
+        // Cancels any inflight init work still holding sessionController.signal
+        // (e.g. a platform init call abandoned after a readiness timeout race).
+        sessionController.abort();
         await Promise.allSettled([resourceLease.release(), metroPortLease?.release()]);
         throw error;
     }

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,kBAmFhC,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;AAmE3D,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,kBA0FhC,CAAC"}

package/dist/run.js

@@ -1,9 +1,20 @@
 import path from 'node:path';
 import { formatResultsErrors } from 'jest-message-util';
 import { toTestResult } from './toTestResult.js';
+import { formatHarnessErrorMessage } from './format-harness-error.js';
 // Helper function to flatten nested test suites into a flat array of tests with hierarchy
 const flattenTests = (suiteResult, ancestorTitles = []) => {
     const tests = [];
+    if (suiteResult.error) {
+        tests.push({
+            name: suiteResult.name,
+            status: 'failed',
+            duration: suiteResult.duration,
+            error: suiteResult.error,
+            ancestorTitles: [...ancestorTitles],
+            fullName: [...ancestorTitles, suiteResult.name].join(' '),
+        });
+    }
     // Add tests from current suite with current hierarchy
     for (const test of suiteResult.tests) {
         tests.push({
@@ -48,10 +59,16 @@ export const runHarnessTestFile = async ({ testPath, globalConfig, projectConfig
     // Extract setup files from Jest config and convert to relative paths
     const setupFiles = projectConfig.setupFiles?.map((setupFile) => path.relative(globalConfig.rootDir, setupFile));
     const setupFilesAfterEnv = projectConfig.setupFilesAfterEnv?.map((setupFile) => path.relative(globalConfig.rootDir, setupFile));
+    const testTimeout = session.config.testTimeout ??
+        projectConfig
+            .testTimeout ??
+        globalConfig
+            .testTimeout;
     const harnessResult = await session.runTestFile(relativeTestPath, {
         testNamePattern: globalConfig.testNamePattern,
         setupFiles,
         setupFilesAfterEnv,
+        testTimeout,
         runner: session.context.platform.runner,
     });
     const end = Date.now();
@@ -59,13 +76,13 @@ export const runHarnessTestFile = async ({ testPath, globalConfig, projectConfig
     const stats = calculateStats(allTests);
     // Convert TestResult[] to the format expected by toTestResult
     const tests = allTests.map((test) => {
-        const errorMessage = test.error?.message;
         const codeFrame = test.error?.codeFrame;
+        const errorMessage = formatHarnessErrorMessage(test.error, {
+            testStartedAt: test.startedAt,
+        });
         return {
             duration: test.duration,
-            errorMessage: errorMessage
-                ? `${errorMessage}${codeFrame ? `\n\n${codeFrame.content}` : ''}`
-                : undefined,
+            errorMessage,
             title: test.name,
             fullName: test.fullName,
             status: test.status,