@react-native-harness/jest 1.3.0 → 1.4.0

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

@@ -24,6 +24,9 @@ export type NativeCrashPhase = 'startup' | 'execution';
 export type NativeCrashDetails = AppCrashDetails & {
     phase: NativeCrashPhase;
 };
+export type RuntimeDisconnectDetails = AppCrashDetails & {
+    phase: NativeCrashPhase;
+};
 export declare class NativeCrashError extends HarnessError {
     readonly testFilePath: string;
     readonly details: NativeCrashDetails;
@@ -31,4 +34,11 @@ export declare class NativeCrashError extends HarnessError {
     constructor(testFilePath: string, details: NativeCrashDetails, lastKnownTest?: string | undefined);
     get phase(): NativeCrashPhase;
 }
+export declare class RuntimeDisconnectError extends HarnessError {
+    readonly testFilePath: string;
+    readonly details: RuntimeDisconnectDetails;
+    constructor(testFilePath: string, details: RuntimeDisconnectDetails);
+    get phase(): NativeCrashPhase;
+}
+export type HarnessRuntimeFailure = NativeCrashError | RuntimeDisconnectError;
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EACL,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,GACzB,MAAM,qCAAqC,CAAC;AAE7C,qBAAa,sBAAuB,SAAQ,YAAY;;CAKvD;AAED,qBAAa,mBAAoB,SAAQ,YAAY;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAED,qBAAa,0BAA2B,SAAQ,YAAY;;CAK3D;AAED,qBAAa,yBAA0B,SAAQ,YAAY;aAC7B,OAAO,EAAE,MAAM;gBAAf,OAAO,EAAE,MAAM;CAM5C;AAED,qBAAa,4BAA6B,SAAQ,YAAY;aAE1C,WAAW,EAAE,MAAM;aACnB,QAAQ,EAAE,MAAM;gBADhB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM;CAQnC;AAED,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,WAAW,CAAC;AAEvD,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG;IACjD,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAmDF,qBAAa,gBAAiB,SAAQ,YAAY;aAE9B,YAAY,EAAE,MAAM;aACpB,OAAO,EAAE,kBAAkB;aAC3B,aAAa,CAAC,EAAE,MAAM;gBAFtB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,kBAAkB,EAC3B,aAAa,CAAC,EAAE,MAAM,YAAA;IAOxC,IAAI,KAAK,qBAER;CACF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,YAAY,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EACL,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,GACzB,MAAM,qCAAqC,CAAC;AAE7C,qBAAa,sBAAuB,SAAQ,YAAY;;CAKvD;AAED,qBAAa,mBAAoB,SAAQ,YAAY;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAED,qBAAa,0BAA2B,SAAQ,YAAY;;CAK3D;AAED,qBAAa,yBAA0B,SAAQ,YAAY;aAC7B,OAAO,EAAE,MAAM;gBAAf,OAAO,EAAE,MAAM;CAM5C;AAED,qBAAa,4BAA6B,SAAQ,YAAY;aAE1C,WAAW,EAAE,MAAM;aACnB,QAAQ,EAAE,MAAM;gBADhB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM;CAQnC;AAED,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,WAAW,CAAC;AAEvD,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG;IACjD,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,eAAe,GAAG;IACvD,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAmEF,qBAAa,gBAAiB,SAAQ,YAAY;aAE9B,YAAY,EAAE,MAAM;aACpB,OAAO,EAAE,kBAAkB;aAC3B,aAAa,CAAC,EAAE,MAAM;gBAFtB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,kBAAkB,EAC3B,aAAa,CAAC,EAAE,MAAM,YAAA;IAOxC,IAAI,KAAK,qBAER;CACF;AA0BD,qBAAa,sBAAuB,SAAQ,YAAY;aAEpC,YAAY,EAAE,MAAM;aACpB,OAAO,EAAE,wBAAwB;gBADjC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,wBAAwB;IAOnD,IAAI,KAAK,qBAER;CACF;AAED,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,GAAG,sBAAsB,CAAC"}

package/dist/errors.js

@@ -1,4 +1,4 @@
-import { HarnessError } from '@react-native-harness/tools';
+import { formatPath, HarnessError } from '@react-native-harness/tools';
 export { StartupStallError, } from '@react-native-harness/bundler-metro';
 export class NoRunnerSpecifiedError extends HarnessError {
     constructor() {
@@ -39,12 +39,21 @@ export class MetroPortRangeExhaustedError extends HarnessError {
         this.name = 'MetroPortRangeExhaustedError';
     }
 }
-const buildNativeCrashMessage = ({ phase, summary, signal, exceptionType, processName, pid, stackTrace, artifactType, }) => {
+const buildNativeCrashMessage = ({ phase, summary, signal, exceptionType, processName, pid, stackTrace, artifactType, artifactPath, enrichmentArtifacts, }) => {
     const lines = [
         phase === 'startup'
             ? 'The native app crashed while preparing to run this test file.'
             : 'The native app crashed during test execution.',
     ];
+    lines.push(artifactPath
+        ? `Harness extracted the crash log: ${formatPath(artifactPath)}`
+        : "Harness couldn't extract the crash log.");
+    if (enrichmentArtifacts && enrichmentArtifacts.length > 0) {
+        lines.push('Additional crash artifacts:');
+        for (const artifact of enrichmentArtifacts) {
+            lines.push(`  - ${formatPath(artifact.artifactPath)}`);
+        }
+    }
     const hasCrashBlock = summary?.includes('\n') ?? false;
     const shouldRenderSummary = Boolean(summary) &&
         !(!hasCrashBlock && artifactType === 'ios-crash-report');
@@ -89,3 +98,33 @@ export class NativeCrashError extends HarnessError {
         return this.details.phase;
     }
 }
+const buildRuntimeDisconnectMessage = ({ phase, summary, rawLines, }) => {
+    const lines = [
+        phase === 'startup'
+            ? 'The native runtime disconnected while preparing to run this test file.'
+            : 'The native runtime disconnected during test execution.',
+    ];
+    if (summary) {
+        lines.push('');
+        lines.push(summary);
+    }
+    if (rawLines && rawLines.length > 0 && summary !== rawLines.join('\n')) {
+        lines.push('');
+        lines.push(...rawLines);
+    }
+    return lines.join('\n');
+};
+export class RuntimeDisconnectError extends HarnessError {
+    testFilePath;
+    details;
+    constructor(testFilePath, details) {
+        super(buildRuntimeDisconnectMessage(details));
+        this.testFilePath = testFilePath;
+        this.details = details;
+        this.name = 'RuntimeDisconnectError';
+        this.stack = `${this.name}: ${this.message.split('\n')[0]}`;
+    }
+    get phase() {
+        return this.details.phase;
+    }
+}

package/dist/execute-run.d.ts

@@ -1,4 +1,6 @@
-import type { OnTestFailure, OnTestStart, OnTestSuccess, Test, TestWatcher, Config } from 'jest-runner';
+import type { Test, TestWatcher, Config, TestEvents } from 'jest-runner';
 import { type HarnessSession } from './harness-session.js';
-export declare const executeRun: (session: HarnessSession, tests: Array<Test>, watcher: TestWatcher, onStart: OnTestStart, onResult: OnTestSuccess, onFailure: OnTestFailure, globalConfig: Config.GlobalConfig) => Promise<void>;
+type EmitTestEvent = <Name extends keyof TestEvents>(eventName: Name, ...eventData: TestEvents[Name]) => Promise<void>;
+export declare const executeRun: (session: HarnessSession, tests: Array<Test>, watcher: TestWatcher, emitEvent: EmitTestEvent, globalConfig: Config.GlobalConfig) => Promise<void>;
+export {};
 //# sourceMappingURL=execute-run.d.ts.map

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,aAAa,EACb,WAAW,EACX,aAAa,EACb,IAAI,EACJ,WAAW,EACX,MAAM,EACP,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,KAAK,cAAc,EAAwB,MAAM,sBAAsB,CAAC;AAsCjF,eAAO,MAAM,UAAU,GACrB,SAAS,cAAc,EACvB,OAAO,KAAK,CAAC,IAAI,CAAC,EAClB,SAAS,WAAW,EACpB,SAAS,WAAW,EACpB,UAAU,aAAa,EACvB,WAAW,aAAa,EACxB,cAAc,MAAM,CAAC,YAAY,KAChC,OAAO,CAAC,IAAI,CA8Id,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,8 +1,14 @@
 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 { 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;
@@ -18,19 +24,71 @@ 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 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;
+    const testCaseResult = {
+        ancestorTitles: event.ancestorTitles,
+        duration: event.duration,
+        failureDetails: [],
+        failureMessages: failureMessage ? [failureMessage] : [],
+        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';
+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();
     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,
@@ -38,6 +96,7 @@ export const executeRun = async (session, tests, watcher, onStart, onResult, onF
             testFiles,
             watchMode,
             coverageEnabled: globalConfig.collectCoverage,
+            completed: false,
             summary,
             status: summary.failed > 0 ? 'failed' : 'passed',
             ...overrides,
@@ -58,8 +117,11 @@ export const executeRun = async (session, tests, watcher, onStart, onResult, onF
         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) {
@@ -79,55 +141,108 @@ export const executeRun = async (session, tests, watcher, onStart, onResult, onF
                 });
             };
             await session.callHook('test-file:started', { runId, file: relativeTestPath });
+            const fileSpan = diagnostics.start('run.file', { file: relativeTestPath });
+            let fileStatus = 'failed';
             try {
-                if (shouldResetEnv && !isFirstTest) {
-                    await session.restartApp(test.path);
+                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;
                 }
-                isFirstTest = false;
-                session.flushClientLogs();
-                await onStart(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 onResult(test, result.jestResult);
-            }
-            catch (err) {
-                if (!emittedTestFileFinished) {
-                    await emitTestFileFinished({
-                        status: 'failed',
-                        duration: Date.now() - fileStartedAt,
-                        result: null,
+                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);
+                    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,
                     });
-                }
-                const isRuntimeFailure = err instanceof NativeCrashError ||
-                    err instanceof StartupStallError ||
-                    err instanceof DeviceNotRespondingError;
-                if (isRuntimeFailure) {
-                    summary.failed += 1;
+                    applyJestResultToSummary(summary, result.jestResult);
+                    const clientLogs = session.flushClientLogs();
+                    if (clientLogs.length > 0) {
+                        result.jestResult.console = clientLogs;
+                    }
                     updateRunState();
+                    fileStatus = result.harnessResult.status;
+                    await emitTestFileFinished({
+                        status: result.harnessResult.status,
+                        duration: result.duration,
+                        result: result.harnessResult,
+                    });
+                    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;
+                    }
                 }
-                if (err instanceof NativeCrashError) {
-                    session.resetCrashState();
+                catch (err) {
+                    fileStatus = 'failed';
+                    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));
                 }
-                updateRunState({ error: isRuntimeFailure ? undefined : err });
-                onFailure(test, buildTestFailure(err));
+            }
+            finally {
+                fileSpan.end({ status: fileStatus });
             }
         }
     }
@@ -137,15 +252,30 @@ export const executeRun = async (session, tests, watcher, onStart, onResult, onF
             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');
+};