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

package/dist/diagnostics/report.d.ts

@@ -0,0 +1,7 @@
+import type { DiagnosticEntry } from '@react-native-harness/tools';
+export declare const writeTraceFile: (entries: DiagnosticEntry[], options: {
+    projectRoot: string;
+    runId: string;
+}) => Promise<string>;
+export declare const printSummary: (entries: DiagnosticEntry[], log: (line: string) => void) => void;
+//# sourceMappingURL=report.d.ts.map

package/dist/diagnostics/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../src/diagnostics/report.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAyCnE,eAAO,MAAM,cAAc,GACzB,SAAS,eAAe,EAAE,EAC1B,SAAS;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,KAC9C,OAAO,CAAC,MAAM,CAUhB,CAAC;AAkBF,eAAO,MAAM,YAAY,GACvB,SAAS,eAAe,EAAE,EAC1B,KAAK,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,KAC1B,IA8CF,CAAC"}

package/dist/diagnostics/report.js

@@ -0,0 +1,84 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getHarnessRootPath } from '@react-native-harness/tools';
+const TRACE_PID = 1;
+const TRACE_TID = 1;
+const toTraceEvent = (entry) => {
+    if (entry.kind === 'mark') {
+        return {
+            name: entry.label,
+            ph: 'i',
+            s: 'g',
+            ts: entry.startTime * 1000,
+            pid: TRACE_PID,
+            tid: TRACE_TID,
+            args: entry.attrs,
+        };
+    }
+    return {
+        name: entry.label,
+        ph: 'X',
+        ts: entry.startTime * 1000,
+        dur: entry.duration * 1000,
+        pid: TRACE_PID,
+        tid: TRACE_TID,
+        args: entry.attrs,
+    };
+};
+export const writeTraceFile = async (entries, options) => {
+    const dir = path.join(getHarnessRootPath(options.projectRoot), 'diagnostics');
+    await fs.mkdir(dir, { recursive: true });
+    const filePath = path.join(dir, `${options.runId}.json`);
+    const trace = { traceEvents: entries.map(toTraceEvent) };
+    await fs.writeFile(filePath, JSON.stringify(trace), 'utf-8');
+    return filePath;
+};
+const formatDuration = (ms) => {
+    if (ms >= 1000) {
+        return `${(ms / 1000).toFixed(1)}s`;
+    }
+    return `${Math.round(ms)}ms`;
+};
+const getNamespace = (label) => label.split('.')[0] ?? label;
+export const printSummary = (entries, log) => {
+    if (entries.length === 0) {
+        return;
+    }
+    const statsByLabel = new Map();
+    for (const entry of entries) {
+        const existing = statsByLabel.get(entry.label);
+        if (existing) {
+            existing.count += 1;
+            existing.totalMs += entry.duration;
+            existing.maxMs = Math.max(existing.maxMs, entry.duration);
+        }
+        else {
+            statsByLabel.set(entry.label, {
+                label: entry.label,
+                count: 1,
+                totalMs: entry.duration,
+                maxMs: entry.duration,
+            });
+        }
+    }
+    const byNamespace = new Map();
+    for (const stats of statsByLabel.values()) {
+        const namespace = getNamespace(stats.label);
+        const group = byNamespace.get(namespace);
+        if (group) {
+            group.push(stats);
+        }
+        else {
+            byNamespace.set(namespace, [stats]);
+        }
+    }
+    log('Diagnostics summary:');
+    const sortedNamespaces = [...byNamespace.entries()].sort(([a], [b]) => a.localeCompare(b));
+    for (const [namespace, group] of sortedNamespaces) {
+        log(`  ${namespace}`);
+        group.sort((a, b) => b.totalMs - a.totalMs);
+        for (const stats of group) {
+            log(`    ${stats.label}: count=${stats.count} total=${formatDuration(stats.totalMs)} max=${formatDuration(stats.maxMs)}`);
+        }
+    }
+};

package/dist/environment-reset.d.ts

@@ -0,0 +1,51 @@
+import type { Config as HarnessConfig } from '@react-native-harness/config';
+export type ResetStrategyKind = 'process' | 'runtime';
+export type EnvironmentResetStrategy = {
+    readonly kind: ResetStrategyKind;
+    reset(ctx: {
+        testFilePath: string;
+    }): Promise<void>;
+};
+/**
+ * Normalizes the `resetEnvironmentBetweenTestFiles` config value into a
+ * strategy kind, or `null` when no reset should happen between test files
+ * (i.e. the value is `false`).
+ */
+export declare const resolveResetStrategyKind: (value: HarnessConfig["resetEnvironmentBetweenTestFiles"]) => ResetStrategyKind | null;
+export type ProcessResetStrategyDeps = {
+    restart: (testFilePath: string) => Promise<void>;
+};
+/**
+ * The 'process' strategy: kill and cold-restart the app process. This is
+ * the same implementation `restartApp` uses for crash/timeout recovery.
+ */
+export declare const createProcessResetStrategy: (deps: ProcessResetStrategyDeps) => EnvironmentResetStrategy;
+export type RuntimeResetConnection = {
+    resetEnvironment: () => Promise<void>;
+};
+export type RuntimeResetStrategyDeps = {
+    getConnection: () => RuntimeResetConnection | null;
+    expectDisconnect: () => () => void;
+    waitForReconnect: (signal: AbortSignal) => Promise<void>;
+    isDisconnectError: (error: unknown) => boolean;
+    timeoutMs: number;
+};
+/**
+ * The 'runtime' strategy: reload the JS runtime in place (DevSettings.reload()
+ * on native, window.location.reload() on web) via the resetEnvironment RPC,
+ * and wait for the bridge to reconnect. The app process stays alive
+ * throughout, so the crash monitor's expected-disconnect window is used to
+ * avoid misclassifying the intentional disconnect as a runtime failure.
+ */
+export declare const createRuntimeResetStrategy: (deps: RuntimeResetStrategyDeps) => EnvironmentResetStrategy;
+export type EscalationOptions = {
+    onEscalate?: (error: unknown) => void;
+};
+/**
+ * Wraps a primary strategy so that any failure (no active connection, RPC
+ * error, reconnect timeout, ...) falls back to running `fallback` instead of
+ * propagating the error. The composite reports the primary's `kind`, since
+ * that's the strategy that was requested.
+ */
+export declare const withEscalation: (primary: EnvironmentResetStrategy, fallback: EnvironmentResetStrategy, options?: EscalationOptions) => EnvironmentResetStrategy;
+//# sourceMappingURL=environment-reset.d.ts.map

package/dist/environment-reset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment-reset.d.ts","sourceRoot":"","sources":["../src/environment-reset.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAI5E,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,SAAS,CAAC;AAEtD,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IAEjC,KAAK,CAAC,GAAG,EAAE;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACrD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GACnC,OAAO,aAAa,CAAC,kCAAkC,CAAC,KACvD,iBAAiB,GAAG,IAQtB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IAErC,OAAO,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAClD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GACrC,MAAM,wBAAwB,KAC7B,wBAGD,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG;IACnC,gBAAgB,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IAErC,aAAa,EAAE,MAAM,sBAAsB,GAAG,IAAI,CAAC;IAGnD,gBAAgB,EAAE,MAAM,MAAM,IAAI,CAAC;IAGnC,gBAAgB,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAIzD,iBAAiB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAE/C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,GACrC,MAAM,wBAAwB,KAC7B,wBAkCD,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG;IAE9B,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACvC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GACzB,SAAS,wBAAwB,EACjC,UAAU,wBAAwB,EAClC,UAAS,iBAAsB,KAC9B,wBAUD,CAAC"}

package/dist/environment-reset.js

@@ -0,0 +1,83 @@
+import { getTimeoutSignal } from '@react-native-harness/tools';
+const ignorePromiseRejection = () => undefined;
+/**
+ * Normalizes the `resetEnvironmentBetweenTestFiles` config value into a
+ * strategy kind, or `null` when no reset should happen between test files
+ * (i.e. the value is `false`).
+ */
+export const resolveResetStrategyKind = (value) => {
+    if (value === false) {
+        return null;
+    }
+    if (value === true) {
+        return 'process';
+    }
+    return value;
+};
+/**
+ * The 'process' strategy: kill and cold-restart the app process. This is
+ * the same implementation `restartApp` uses for crash/timeout recovery.
+ */
+export const createProcessResetStrategy = (deps) => ({
+    kind: 'process',
+    reset: ({ testFilePath }) => deps.restart(testFilePath),
+});
+/**
+ * The 'runtime' strategy: reload the JS runtime in place (DevSettings.reload()
+ * on native, window.location.reload() on web) via the resetEnvironment RPC,
+ * and wait for the bridge to reconnect. The app process stays alive
+ * throughout, so the crash monitor's expected-disconnect window is used to
+ * avoid misclassifying the intentional disconnect as a runtime failure.
+ */
+export const createRuntimeResetStrategy = (deps) => ({
+    kind: 'runtime',
+    reset: async () => {
+        const connection = deps.getConnection();
+        if (!connection) {
+            throw new Error('No active app connection to reset the runtime on');
+        }
+        const closeWindow = deps.expectDisconnect();
+        try {
+            // Start listening for the reconnect before firing the RPC, so a fast
+            // reload can't reconnect before we're watching for it.
+            const reconnected = deps.waitForReconnect(getTimeoutSignal(deps.timeoutMs));
+            // Observe the rejection even when the RPC throws first, so the timeout
+            // abort firing later can't become an unhandled rejection. (.catch()
+            // returns a new promise; the original is what gets awaited below.)
+            reconnected.catch(ignorePromiseRejection);
+            try {
+                await connection.resetEnvironment();
+            }
+            catch (error) {
+                // The reload can tear the runtime down before the RPC ack flushes.
+                // A disconnect-flavored rejection means the reload is in flight, so
+                // keep waiting for the reconnect; anything else is a real failure.
+                if (!deps.isDisconnectError(error)) {
+                    throw error;
+                }
+            }
+            await reconnected;
+        }
+        finally {
+            closeWindow();
+        }
+    },
+});
+/**
+ * Wraps a primary strategy so that any failure (no active connection, RPC
+ * error, reconnect timeout, ...) falls back to running `fallback` instead of
+ * propagating the error. The composite reports the primary's `kind`, since
+ * that's the strategy that was requested.
+ */
+export const withEscalation = (primary, fallback, options = {}) => ({
+    kind: primary.kind,
+    reset: async (ctx) => {
+        try {
+            await primary.reset(ctx);
+        }
+        catch (error) {
+            options.onEscalate?.(error);
+            await fallback.reset(ctx);
+        }
+    },
+});

package/dist/execute-run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute-run.d.ts","sourceRoot":"","sources":["../src/execute-run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,WAAW,EACX,MAAM,EACN,UAAU,EACX,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,sBAAsB,CAAC;AAsBjF,KAAK,aAAa,GAAG,CAAC,IAAI,SAAS,MAAM,UAAU,EACjD,SAAS,EAAE,IAAI,EACf,GAAG,SAAS,EAAE,UAAU,CAAC,IAAI,CAAC,KAC3B,OAAO,CAAC,IAAI,CAAC,CAAC;AAmFnB,eAAO,MAAM,UAAU,GACrB,SAAS,cAAc,EACvB,OAAO,KAAK,CAAC,IAAI,CAAC,EAClB,SAAS,WAAW,EACpB,WAAW,aAAa,EACxB,cAAc,MAAM,CAAC,YAAY,KAChC,OAAO,CAAC,IAAI,CA8Ld,CAAC"}
+{"version":3,"file":"execute-run.d.ts","sourceRoot":"","sources":["../src/execute-run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,WAAW,EACX,MAAM,EACN,UAAU,EACX,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,sBAAsB,CAAC;AA6BjF,KAAK,aAAa,GAAG,CAAC,IAAI,SAAS,MAAM,UAAU,EACjD,SAAS,EAAE,IAAI,EACf,GAAG,SAAS,EAAE,UAAU,CAAC,IAAI,CAAC,KAC3B,OAAO,CAAC,IAAI,CAAC,CAAC;AA+FnB,eAAO,MAAM,UAAU,GACrB,SAAS,cAAc,EACvB,OAAO,KAAK,CAAC,IAAI,CAAC,EAClB,SAAS,WAAW,EACpB,WAAW,aAAa,EACxB,cAAc,MAAM,CAAC,YAAY,KAChC,OAAO,CAAC,IAAI,CAsOd,CAAC"}

package/dist/execute-run.js

@@ -1,9 +1,14 @@
 import { randomUUID } from 'node:crypto';
 import path from 'node:path';
 import { runHarnessTestFile } from './run.js';
+import { resolveResetStrategyKind } from './environment-reset.js';
 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';
+import { formatHarnessErrorMessage } from './format-harness-error.js';
+import { logger } from '@react-native-harness/tools';
+import { printSummary, writeTraceFile } from './diagnostics/index.js';
+const diagnosticsLogger = logger.child('diagnostics');
 const createRunSummary = () => ({ passed: 0, failed: 0, skipped: 0, todo: 0 });
 const applyJestResultToSummary = (summary, result) => {
     summary.passed += result.numPassingTests;
@@ -38,8 +43,10 @@ const emitHarnessTestStarted = async (emitEvent, event) => {
     });
 };
 const emitHarnessTestFinished = async (emitEvent, event) => {
-    const failureMessage = event.error?.message;
     const codeFrame = event.error?.codeFrame;
+    const failureMessage = formatHarnessErrorMessage(event.error, {
+        testStartedAt: event.startedAt,
+    });
     const location = codeFrame?.location
         ? { column: codeFrame.location.column, line: codeFrame.location.row }
         : null;
@@ -47,9 +54,7 @@ const emitHarnessTestFinished = async (emitEvent, event) => {
         ancestorTitles: event.ancestorTitles,
         duration: event.duration,
         failureDetails: [],
-        failureMessages: failureMessage
-            ? [`${failureMessage}${codeFrame ? `\n\n${codeFrame.content}` : ''}`]
-            : [],
+        failureMessages: failureMessage ? [failureMessage] : [],
         fullName: event.fullName,
         location,
         numPassingAsserts: event.status === 'passed' ? 1 : 0,
@@ -60,8 +65,17 @@ const emitHarnessTestFinished = async (emitEvent, event) => {
     await emitEvent('test-case-result', event.file, testCaseResult);
 };
 const isHarnessCaseEvent = (event) => event.type === 'test-started' || event.type === 'test-finished';
+const TIMEOUT_ERROR_NAMES = new Set([
+    'SuiteHookTimeoutError',
+    'TestCaseTimeoutError',
+]);
+const hasRuntimeTimeout = (result) => (result.error ? TIMEOUT_ERROR_NAMES.has(result.error.name) : false) ||
+    result.tests.some((test) => test.error ? TIMEOUT_ERROR_NAMES.has(test.error.name) : false) ||
+    result.suites.some(hasRuntimeTimeout);
 export const executeRun = async (session, tests, watcher, emitEvent, globalConfig) => {
     const runId = randomUUID();
+    const diagnostics = session.diagnostics.child({ runId });
+    const runSpan = diagnostics.start('run.total', { runId });
     const startTime = Date.now();
     const watchMode = globalConfig.watch || globalConfig.watchAll;
     const rootDir = globalConfig.rootDir ?? process.cwd();
@@ -82,6 +96,7 @@ export const executeRun = async (session, tests, watcher, emitEvent, globalConfi
             testFiles,
             watchMode,
             coverageEnabled: globalConfig.collectCoverage,
+            completed: false,
             summary,
             status: summary.failed > 0 ? 'failed' : 'passed',
             ...overrides,
@@ -102,10 +117,11 @@ export const executeRun = async (session, tests, watcher, emitEvent, globalConfi
         port: session.config.metroPort,
         host: session.config.host?.trim() || undefined,
     });
-    const shouldResetEnv = session.config.resetEnvironmentBetweenTestFiles;
+    const resetStrategyKind = resolveResetStrategyKind(session.config.resetEnvironmentBetweenTestFiles);
     const platformId = session.context.platform.platformId;
     const knownPlatformIds = new Set(session.config.runners.map((runner) => runner.platformId));
     let isFirstTest = true;
+    let shouldRestartAfterTimeout = false;
     let runError;
     try {
         for (const test of tests) {
@@ -125,20 +141,82 @@ export const executeRun = async (session, tests, watcher, emitEvent, globalConfi
                 });
             };
             await session.callHook('test-file:started', { runId, file: relativeTestPath });
-            if (!shouldRunHarnessTestFile(test.path, platformId, knownPlatformIds)) {
+            const fileSpan = diagnostics.start('run.file', { file: relativeTestPath });
+            let fileStatus = 'failed';
+            try {
+                if (!shouldRunHarnessTestFile(test.path, platformId, knownPlatformIds)) {
+                    try {
+                        await emitEvent('test-file-start', test);
+                        const skippedResult = createPlatformSkippedTestResult(test.path);
+                        applyJestResultToSummary(summary, skippedResult);
+                        updateRunState();
+                        fileStatus = 'skipped';
+                        await emitTestFileFinished({
+                            status: 'skipped',
+                            duration: Date.now() - fileStartedAt,
+                            result: null,
+                        });
+                        await emitEvent('test-file-success', test, skippedResult);
+                    }
+                    catch (err) {
+                        fileStatus = 'failed';
+                        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 (shouldRestartAfterTimeout) {
+                        // Recovery from a runtime timeout always uses the (stronger)
+                        // process restart, never the configured reset strategy.
+                        await session.restartApp(test.path);
+                        shouldRestartAfterTimeout = false;
+                    }
+                    else if (resetStrategyKind !== null && !isFirstTest) {
+                        await session.resetEnvironment(test.path);
+                    }
+                    isFirstTest = false;
+                    session.flushClientLogs();
                     await emitEvent('test-file-start', test);
-                    const skippedResult = createPlatformSkippedTestResult(test.path);
-                    applyJestResultToSummary(summary, skippedResult);
+                    await session.ensureAppReady(test.path);
+                    // Crash detection is handled inside session.runTestFile; NativeCrashError
+                    // propagates here if a crash wins the race.
+                    const result = await runHarnessTestFile({
+                        testPath: test.path,
+                        session,
+                        globalConfig,
+                        projectConfig: test.context.config,
+                    });
+                    applyJestResultToSummary(summary, result.jestResult);
+                    const clientLogs = session.flushClientLogs();
+                    if (clientLogs.length > 0) {
+                        result.jestResult.console = clientLogs;
+                    }
                     updateRunState();
+                    fileStatus = result.harnessResult.status;
                     await emitTestFileFinished({
-                        status: 'skipped',
-                        duration: Date.now() - fileStartedAt,
-                        result: null,
+                        status: result.harnessResult.status,
+                        duration: result.duration,
+                        result: result.harnessResult,
                     });
-                    await emitEvent('test-file-success', test, skippedResult);
+                    const didRuntimeTimeout = hasRuntimeTimeout(result.harnessResult);
+                    shouldRestartAfterTimeout = didRuntimeTimeout;
+                    await caseEventChain;
+                    await emitEvent('test-file-success', test, result.jestResult);
+                    if (didRuntimeTimeout) {
+                        await session.restartApp(test.path);
+                        shouldRestartAfterTimeout = false;
+                    }
                 }
                 catch (err) {
+                    fileStatus = 'failed';
                     if (!emittedTestFileFinished) {
                         await emitTestFileFinished({
                             status: 'failed',
@@ -146,64 +224,25 @@ export const executeRun = async (session, tests, watcher, emitEvent, globalConfi
                             result: null,
                         });
                     }
-                    updateRunState({ error: err });
+                    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 || err instanceof RuntimeDisconnectError) {
+                        session.resetCrashState();
+                    }
+                    updateRunState({ error: isRuntimeFailure ? undefined : err });
+                    await caseEventChain;
                     await emitEvent('test-file-failure', test, buildTestFailure(err));
                 }
-                continue;
             }
-            try {
-                if (shouldResetEnv && !isFirstTest) {
-                    await session.restartApp(test.path);
-                }
-                isFirstTest = false;
-                session.flushClientLogs();
-                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.
-                const result = await runHarnessTestFile({
-                    testPath: test.path,
-                    session,
-                    globalConfig,
-                    projectConfig: test.context.config,
-                });
-                applyJestResultToSummary(summary, result.jestResult);
-                const clientLogs = session.flushClientLogs();
-                if (clientLogs.length > 0) {
-                    result.jestResult.console = clientLogs;
-                }
-                updateRunState();
-                await emitTestFileFinished({
-                    status: result.harnessResult.status,
-                    duration: result.duration,
-                    result: result.harnessResult,
-                });
-                await caseEventChain;
-                await emitEvent('test-file-success', test, result.jestResult);
-            }
-            catch (err) {
-                if (!emittedTestFileFinished) {
-                    await emitTestFileFinished({
-                        status: 'failed',
-                        duration: Date.now() - fileStartedAt,
-                        result: null,
-                    });
-                }
-                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 || err instanceof RuntimeDisconnectError) {
-                    session.resetCrashState();
-                }
-                updateRunState({ error: isRuntimeFailure ? undefined : err });
-                await caseEventChain;
-                await emitEvent('test-file-failure', test, buildTestFailure(err));
+            finally {
+                fileSpan.end({ status: fileStatus });
             }
         }
     }
@@ -213,17 +252,30 @@ export const executeRun = async (session, tests, watcher, emitEvent, globalConfi
             throw err;
     }
     finally {
-        const runState = updateRunState(runError != null ? { error: runError, status: 'failed' } : {});
+        const runState = updateRunState(runError != null ? { completed: true, error: runError, status: 'failed' } : { completed: true });
+        const finalStatus = runState.status ?? (runError != null ? 'failed' : 'passed');
         await session.callHook('run:finished', {
             runId,
             startTime,
             duration: Date.now() - startTime,
             testFiles,
             summary,
-            status: runState.status ?? (runError != null ? 'failed' : 'passed'),
+            status: finalStatus,
             ...(runError != null ? { error: runError } : {}),
         });
         await caseEventChain;
         unsubscribe();
+        runSpan.end({ runId, status: finalStatus });
+        if (session.diagnostics.enabled) {
+            const entries = session.diagnostics.flush();
+            try {
+                printSummary(entries, (line) => diagnosticsLogger.info(line));
+                const tracePath = await writeTraceFile(entries, { projectRoot: rootDir, runId });
+                diagnosticsLogger.info(`wrote diagnostics trace to ${tracePath}`);
+            }
+            catch (reportError) {
+                diagnosticsLogger.warn('failed to write diagnostics report: %s', reportError);
+            }
+        }
     }
 };

package/dist/format-harness-error.d.ts

@@ -0,0 +1,5 @@
+import type { SerializedError } from '@react-native-harness/bridge';
+export declare const formatHarnessErrorMessage: (error: SerializedError | undefined, options?: {
+    testStartedAt?: number;
+}) => string | undefined;
+//# sourceMappingURL=format-harness-error.d.ts.map

package/dist/format-harness-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-harness-error.d.ts","sourceRoot":"","sources":["../src/format-harness-error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AA6CpE,eAAO,MAAM,yBAAyB,GACpC,OAAO,eAAe,GAAG,SAAS,EAClC,UAAS;IACP,aAAa,CAAC,EAAE,MAAM,CAAC;CACnB,KACL,MAAM,GAAG,SAsBX,CAAC"}

package/dist/format-harness-error.js

@@ -0,0 +1,43 @@
+const formatPendingPromiseStack = (stack) => stack
+    .split('\n')
+    .map((line) => `  ${line}`)
+    .join('\n');
+const formatPendingPromises = (pendingPromises, testStartedAt) => {
+    if (pendingPromises.total === 0) {
+        return null;
+    }
+    const lines = [`Pending promises at timeout: ${pendingPromises.total}`];
+    if (pendingPromises.items.length < pendingPromises.total) {
+        lines.push(`Showing ${pendingPromises.items.length} of ${pendingPromises.total} pending promises.`);
+    }
+    for (const promise of pendingPromises.items) {
+        const age = testStartedAt !== undefined
+            ? `, created ${Math.max(0, promise.createdAt - testStartedAt)}ms after test start`
+            : '';
+        lines.push('');
+        lines.push(`Promise #${promise.id}${age}:`);
+        if (promise.stack) {
+            lines.push(formatPendingPromiseStack(promise.stack));
+        }
+        else {
+            lines.push('  <stack unavailable>');
+        }
+    }
+    return lines.join('\n');
+};
+export const formatHarnessErrorMessage = (error, options = {}) => {
+    if (!error) {
+        return undefined;
+    }
+    const parts = [error.message];
+    const pendingPromiseDetails = error.diagnostics?.pendingPromises
+        ? formatPendingPromises(error.diagnostics.pendingPromises, options.testStartedAt)
+        : null;
+    if (pendingPromiseDetails) {
+        parts.push(pendingPromiseDetails);
+    }
+    if (error.codeFrame) {
+        parts.push(error.codeFrame.content);
+    }
+    return parts.join('\n\n');
+};

package/dist/harness-session.d.ts

@@ -1,7 +1,8 @@
-import { type AppConnection } from '@react-native-harness/bridge/server';
+import { type HarnessBridge, 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 Diagnostics } from '@react-native-harness/tools';
 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';
@@ -17,12 +18,17 @@ export declare const waitForBridgeDisconnectOrTimeout: ({ bridge, connection, ti
     connection: AppConnection;
     timeoutMs: number;
 }) => Promise<boolean>;
+export declare const waitForNextConnected: ({ bridge, signal, }: {
+    bridge: Pick<HarnessBridge, "on" | "off">;
+    signal: AbortSignal;
+}) => Promise<void>;
 export type HarnessRunState = {
     readonly runId: string;
     readonly startTime: number;
     readonly testFiles: string[];
     readonly watchMode: boolean;
     readonly coverageEnabled: boolean;
+    readonly completed?: boolean;
     readonly summary?: HarnessRunSummary;
     readonly status?: HarnessRunStatus;
     readonly error?: unknown;
@@ -31,22 +37,41 @@ export type HarnessRunTestsOptions = Exclude<TestExecutionOptions, 'platform'>;
 export type HarnessSession = {
     readonly config: HarnessConfig;
     readonly context: HarnessContext;
+    readonly diagnostics: Diagnostics;
     onTestRunnerEvent: (listener: (event: TestRunnerEvents) => void) => () => void;
     runTestFile: (path: string, options: HarnessRunTestsOptions) => Promise<TestSuiteResult>;
     ensureAppReady: (testFilePath: string) => Promise<void>;
     restartApp: (testFilePath?: string) => Promise<void>;
+    resetEnvironment: (testFilePath: string) => Promise<void>;
     resetCrashState: () => void;
     flushClientLogs: () => ClientLogBuffer;
     callHook: HarnessPluginManager<HarnessConfig, HarnessPlatform>['callHook'];
     setRunState: (state: HarnessRunState | null) => void;
     dispose: (reason?: 'normal' | 'abort' | 'error') => Promise<void>;
 };
+export declare const getSignalExitCodeForRunState: (state: HarnessRunState | null) => number;
+export declare const withPlatformReadyTimeout: <T>(options: {
+    timeout: number;
+    signal: AbortSignal;
+    work: (signal: AbortSignal) => Promise<T>;
+}) => Promise<T>;
 export declare const waitForStartupCrash: ({ crashMonitor, detectNativeCrashes, testFilePath, signal, }: {
     crashMonitor: CrashMonitor;
     detectNativeCrashes: boolean;
     testFilePath: string;
     signal: AbortSignal;
 }) => Promise<never>;
+/**
+ * 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 declare const maybeLogMetroCacheReused: (options: {
+    config: Pick<HarnessConfig, "cache" | "unstable__enableMetroCache">;
+    projectRoot: string;
+    platform: HarnessPlatform;
+}) => void;
 export declare const createHarnessSession: (globalConfig: JestConfig.GlobalConfig, { lockManager }?: {
     lockManager?: ResourceLockManager;
 }) => Promise<HarnessSession>;

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

@@ -1 +1 @@
-{"version":3,"file":"harness-session.d.ts","sourceRoot":"","sources":["../src/harness-session.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"harness-session.d.ts","sourceRoot":"","sources":["../src/harness-session.ts"],"names":[],"mappings":"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"}