@react-native-harness/jest 1.1.0-rc.1 → 1.1.0-rc.2

package/dist/harness.d.ts

@@ -1,9 +1,21 @@
 import { BridgeServer } from '@react-native-harness/bridge/server';
 import { HarnessContext, TestExecutionOptions, TestSuiteResult } from '@react-native-harness/bridge';
 import { type AppLaunchOptions, HarnessPlatform, HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { type MetroInstance } from '@react-native-harness/bundler-metro';
+import { type HarnessPluginManager, type HarnessRunStatus, type HarnessRunSummary } from '@react-native-harness/plugins';
 import { Config as HarnessConfig } from '@react-native-harness/config';
 import { type CrashSupervisor } from './crash-supervisor.js';
 export type HarnessRunTestsOptions = Exclude<TestExecutionOptions, 'platform'>;
+export type HarnessRunState = {
+    runId: string;
+    startTime: number;
+    testFiles: string[];
+    watchMode: boolean;
+    coverageEnabled: boolean;
+    summary?: HarnessRunSummary;
+    status?: HarnessRunStatus;
+    error?: unknown;
+};
 export type Harness = {
     context: HarnessContext;
     runTests: (path: string, options: HarnessRunTestsOptions) => Promise<TestSuiteResult>;
@@ -11,14 +23,24 @@ export type Harness = {
     restart: (testFilePath?: string) => Promise<void>;
     dispose: () => Promise<void>;
     crashSupervisor: CrashSupervisor;
+    callHook: HarnessPluginManager<HarnessConfig, HarnessPlatform>['callHook'];
+    setRunState: (runState: HarnessRunState | null) => void;
+    getRunState: () => HarnessRunState | null;
 };
+export declare const maybeLogMetroCacheReuse: (config: HarnessConfig, platform: HarnessPlatform, projectRoot: string) => void;
 export declare const waitForAppReady: (options: {
+    metroInstance: MetroInstance;
     serverBridge: BridgeServer;
     platformInstance: HarnessPlatformRunner;
-    bridgeTimeout: number;
+    platformId: string;
+    bundleStartTimeout: number;
+    readyTimeout: number;
+    maxAppRestarts: number;
     testFilePath: string;
     crashSupervisor: CrashSupervisor;
+    signal?: AbortSignal;
     appLaunchOptions?: AppLaunchOptions;
+    launchApp?: () => Promise<void>;
 }) => Promise<void>;
 export declare const getHarness: (config: HarnessConfig, platform: HarnessPlatform, projectRoot: string) => Promise<Harness>;
 //# sourceMappingURL=harness.d.ts.map

package/dist/harness.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../src/harness.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EACb,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,eAAe,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,gBAAgB,EACrB,eAAe,EACf,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AAOzC,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,uBAAuB,CAAC;AAI/B,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,oBAAoB,EAAE,UAAU,CAAC,CAAC;AAE/E,MAAM,MAAM,OAAO,GAAG;IACpB,OAAO,EAAE,cAAc,CAAC;IACxB,QAAQ,EAAE,CACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,sBAAsB,KAC5B,OAAO,CAAC,eAAe,CAAC,CAAC;IAC9B,cAAc,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,OAAO,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,SAAS;IAC7C,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,EAAE,qBAAqB,CAAC;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,eAAe,CAAC;IACjC,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,KAAG,OAAO,CAAC,IAAI,CA+Cf,CAAC;AAyIF,eAAO,MAAM,UAAU,GACrB,QAAQ,aAAa,EACrB,UAAU,eAAe,EACzB,aAAa,MAAM,KAClB,OAAO,CAAC,OAAO,CAkBjB,CAAC"}
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../src/harness.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EACb,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACL,cAAc,EAGd,oBAAoB,EACpB,eAAe,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EAEL,KAAK,gBAAgB,EACrB,eAAe,EACf,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACvB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,uBAAuB,CAAC;AAO/B,MAAM,MAAM,sBAAsB,GAAG,OAAO,CAAC,oBAAoB,EAAE,UAAU,CAAC,CAAC;AAE/E,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,OAAO,GAAG;IACpB,OAAO,EAAE,cAAc,CAAC;IACxB,QAAQ,EAAE,CACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,sBAAsB,KAC5B,OAAO,CAAC,eAAe,CAAC,CAAC;IAC9B,cAAc,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,OAAO,EAAE,CAAC,YAAY,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,eAAe,EAAE,eAAe,CAAC;IACjC,QAAQ,EAAE,oBAAoB,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC,UAAU,CAAC,CAAC;IAC3E,WAAW,EAAE,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI,KAAK,IAAI,CAAC;IACxD,WAAW,EAAE,MAAM,eAAe,GAAG,IAAI,CAAC;CAC3C,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,EACrB,UAAU,eAAe,EACzB,aAAa,MAAM,KAClB,IAOF,CAAC;AAqBF,eAAO,MAAM,eAAe,GAAU,SAAS;IAC7C,aAAa,EAAE,aAAa,CAAC;IAC7B,YAAY,EAAE,YAAY,CAAC;IAC3B,gBAAgB,EAAE,qBAAqB,CAAC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,eAAe,CAAC;IACjC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC,KAAG,OAAO,CAAC,IAAI,CA2Ef,CAAC;AAkeF,eAAO,MAAM,UAAU,GACrB,QAAQ,aAAa,EACrB,UAAU,eAAe,EACzB,aAAa,MAAM,KAClB,OAAO,CAAC,OAAO,CAsBjB,CAAC"}

package/dist/harness.js

@@ -1,55 +1,158 @@
 import { getBridgeServer, } from '@react-native-harness/bridge/server';
-import { getMetroInstance, prewarmMetroBundle, } from '@react-native-harness/bundler-metro';
-import { createCrashArtifactWriter } from '@react-native-harness/tools';
+import { getMetroInstance, isMetroCacheReusable, waitForMetroBackedAppReady, } from '@react-native-harness/bundler-metro';
+import { createHarnessPluginManager, } from '@react-native-harness/plugins';
+import { logger, createCrashArtifactWriter } from '@react-native-harness/tools';
 import { InitializationTimeoutError } from './errors.js';
 import { createCrashSupervisor, } from './crash-supervisor.js';
 import { createClientLogListener } from './client-log-handler.js';
-import { logMetroPrewarmCompleted } from './logs.js';
+import path from 'node:path';
+import { logMetroCacheReused } from './logs.js';
+const harnessLogger = logger.child('runtime');
+export const maybeLogMetroCacheReuse = (config, platform, projectRoot) => {
+    if (config.unstable__enableMetroCache &&
+        isMetroCacheReusable(projectRoot)) {
+        logMetroCacheReused(platform);
+    }
+};
+const createAbortError = () => new DOMException('The operation was aborted', 'AbortError');
+const waitForAbort = (signal) => {
+    if (signal.aborted) {
+        return Promise.reject(signal.reason ?? createAbortError());
+    }
+    return new Promise((_, reject) => {
+        signal.addEventListener('abort', () => {
+            reject(signal.reason ?? createAbortError());
+        }, { once: true });
+    });
+};
 export const waitForAppReady = async (options) => {
-    const { serverBridge, platformInstance, bridgeTimeout, testFilePath, crashSupervisor, appLaunchOptions, } = options;
-    const signal = AbortSignal.timeout(bridgeTimeout);
-    return new Promise((resolve, reject) => {
-        const launchApp = async () => {
+    const { metroInstance, serverBridge, platformInstance, platformId, bundleStartTimeout, readyTimeout, maxAppRestarts, testFilePath, crashSupervisor, appLaunchOptions, launchApp = () => platformInstance.restartApp(appLaunchOptions), } = options;
+    const signal = options.signal ?? new AbortController().signal;
+    const logWait = (message, ...args) => {
+        harnessLogger.debug(`waitForAppReady: ${message}`, ...args);
+    };
+    return await waitForMetroBackedAppReady({
+        metro: metroInstance,
+        platformId,
+        bundleStartTimeout,
+        readyTimeout,
+        maxAppRestarts,
+        signal,
+        startAttempt: async () => {
+            logWait('launching app for %s', testFilePath);
+            await launchApp();
+            logWait('launch request completed, waiting for bridge ready');
+        },
+        waitForReady: async (signal) => {
+            logWait('waiting for runtime ready');
+            return await Promise.race([
+                new Promise((resolve) => {
+                    const onReady = () => {
+                        cleanup();
+                        crashSupervisor.markReady();
+                        logWait('runtime ready received');
+                        resolve();
+                    };
+                    const onAbort = () => {
+                        cleanup();
+                    };
+                    const cleanup = () => {
+                        serverBridge.off('ready', onReady);
+                        signal.removeEventListener('abort', onAbort);
+                    };
+                    serverBridge.on('ready', onReady);
+                    signal.addEventListener('abort', onAbort, { once: true });
+                }),
+                waitForAbort(signal),
+            ]);
+        },
+        waitForCrash: async (signal) => {
+            try {
+                logWait('waiting for crash or runtime ready');
+                return await Promise.race([
+                    crashSupervisor.waitForCrash(testFilePath),
+                    waitForAbort(signal),
+                ]);
+            }
+            finally {
+                crashSupervisor.cancelCrashWaiters();
+            }
+        },
+        onAttemptStart: () => {
+            logWait('beginning launch attempt for %s', testFilePath);
             crashSupervisor.beginLaunch(testFilePath);
-            await platformInstance.restartApp(appLaunchOptions);
-        };
-        const onReady = () => {
-            crashSupervisor.markReady();
-            cleanup();
-            resolve();
-        };
-        const onAbort = () => {
-            cleanup();
-            reject(new DOMException('The operation was aborted', 'AbortError'));
-        };
-        const cleanup = () => {
-            serverBridge.off('ready', onReady);
-            signal.removeEventListener('abort', onAbort);
+        },
+        onAttemptReset: () => {
+            logWait('resetting launch attempt state');
             crashSupervisor.cancelCrashWaiters();
-        };
-        signal.addEventListener('abort', onAbort);
-        serverBridge.once('ready', onReady);
-        void crashSupervisor.waitForCrash(testFilePath).catch((error) => {
-            cleanup();
-            reject(error);
-        });
-        void launchApp().catch((error) => {
-            cleanup();
-            reject(error);
-        });
+        },
     });
 };
 const getHarnessInternal = async (config, platform, projectRoot, signal) => {
     const context = {
         platform,
     };
+    harnessLogger.debug('creating Harness internals for runner=%s platform=%s', platform.name, platform.platformId);
+    maybeLogMetroCacheReuse(config, platform, projectRoot);
+    const pluginAbortController = new AbortController();
+    const pluginManager = createHarnessPluginManager({
+        plugins: (config.plugins ?? []),
+        projectRoot,
+        config,
+        runner: platform,
+        abortSignal: pluginAbortController.signal,
+    });
+    let currentRun = null;
+    let activeTestFilePath;
+    const pendingHookPromises = new Set();
+    let pendingHookError;
+    const getCurrentRunId = () => currentRun?.runId;
+    const toRelativeTestFilePath = (testFilePath) => testFilePath == null ? undefined : path.relative(projectRoot, testFilePath);
+    const setActiveTestFilePath = (testFilePath) => {
+        activeTestFilePath = toRelativeTestFilePath(testFilePath);
+    };
+    const flushPendingHooks = async () => {
+        if (pendingHookPromises.size > 0) {
+            await Promise.allSettled([...pendingHookPromises]);
+        }
+        if (pendingHookError !== undefined) {
+            const error = pendingHookError;
+            pendingHookError = undefined;
+            throw error;
+        }
+    };
+    const trackHook = (promise) => {
+        const trackedPromise = promise
+            .catch((error) => {
+            pendingHookError ??= error;
+        })
+            .finally(() => {
+            pendingHookPromises.delete(trackedPromise);
+        });
+        pendingHookPromises.add(trackedPromise);
+    };
+    const scheduleHook = (name, payload) => {
+        trackHook(pluginManager.callHook(name, payload));
+    };
+    harnessLogger.debug('starting Metro, platform runner, and bridge initialization');
     const [metroInstance, platformInstance, serverBridge] = await Promise.all([
-        getMetroInstance({ projectRoot, harnessConfig: config }, signal),
-        import(platform.runner).then((module) => module.default(platform.config, config)),
+        getMetroInstance({ projectRoot, harnessConfig: config }, signal).then((instance) => {
+            harnessLogger.debug('Metro initialized');
+            return instance;
+        }),
+        import(platform.runner)
+            .then((module) => module.default(platform.config, config))
+            .then((instance) => {
+            harnessLogger.debug('platform runner initialized');
+            return instance;
+        }),
         getBridgeServer({
             port: config.webSocketPort,
             timeout: config.bridgeTimeout,
             context,
+        }).then((bridge) => {
+            harnessLogger.debug('bridge server initialized on port %d', config.webSocketPort);
+            return bridge;
         }),
     ]);
     const crashArtifactWriter = createCrashArtifactWriter({
@@ -61,67 +164,293 @@ const getHarnessInternal = async (config, platform, projectRoot, signal) => {
     });
     const appLaunchOptions = platform.config.appLaunchOptions;
     const clientLogListener = createClientLogListener();
+    const bridgeEventListener = (event) => {
+        const runId = getCurrentRunId();
+        if (!runId) {
+            return;
+        }
+        switch (event.type) {
+            case 'collection-started':
+                scheduleHook('collection:started', {
+                    runId,
+                    file: event.file,
+                });
+                break;
+            case 'collection-finished':
+                scheduleHook('collection:finished', {
+                    runId,
+                    file: event.file,
+                    duration: event.duration,
+                    totalTests: event.totalTests,
+                });
+                break;
+            case 'suite-started':
+                scheduleHook('suite:started', {
+                    runId,
+                    file: event.file,
+                    name: event.name,
+                });
+                break;
+            case 'suite-finished':
+                scheduleHook('suite:finished', {
+                    runId,
+                    file: event.file,
+                    name: event.name,
+                    duration: event.duration,
+                    status: event.status,
+                    error: event.error,
+                });
+                break;
+            case 'test-started':
+                scheduleHook('test:started', {
+                    runId,
+                    file: event.file,
+                    suite: event.suite,
+                    name: event.name,
+                });
+                break;
+            case 'test-finished':
+                scheduleHook('test:finished', {
+                    runId,
+                    file: event.file,
+                    suite: event.suite,
+                    name: event.name,
+                    duration: event.duration,
+                    status: event.status,
+                    error: event.error,
+                });
+                break;
+            case 'module-bundling-started':
+                scheduleHook('metro:bundle-started', {
+                    runId,
+                    target: 'module',
+                    file: event.file,
+                });
+                break;
+            case 'module-bundling-finished':
+                scheduleHook('metro:bundle-finished', {
+                    runId,
+                    target: 'module',
+                    file: event.file,
+                    duration: event.duration,
+                });
+                break;
+            case 'module-bundling-failed':
+                scheduleHook('metro:bundle-failed', {
+                    runId,
+                    target: 'module',
+                    file: event.file,
+                    duration: event.duration,
+                    error: event.error,
+                });
+                break;
+            case 'setup-file-bundling-started':
+                scheduleHook('metro:bundle-started', {
+                    runId,
+                    target: 'setupFile',
+                    file: event.file,
+                    setupType: event.setupType,
+                });
+                break;
+            case 'setup-file-bundling-finished':
+                scheduleHook('metro:bundle-finished', {
+                    runId,
+                    target: 'setupFile',
+                    file: event.file,
+                    setupType: event.setupType,
+                    duration: event.duration,
+                });
+                break;
+            case 'setup-file-bundling-failed':
+                scheduleHook('metro:bundle-failed', {
+                    runId,
+                    target: 'setupFile',
+                    file: event.file,
+                    setupType: event.setupType,
+                    duration: event.duration,
+                    error: event.error,
+                });
+                break;
+        }
+    };
+    const onMetroEvent = (event) => {
+        const runId = getCurrentRunId();
+        if (runId && event.type === 'client_log') {
+            scheduleHook('metro:client-log', {
+                runId,
+                level: event.level,
+                data: event.data,
+            });
+        }
+    };
     const crashSupervisor = createCrashSupervisor({
         appMonitor,
         platformRunner: platformInstance,
     });
-    serverBridge.on('ready', crashSupervisor.markReady);
+    const onReady = (device) => {
+        crashSupervisor.markReady();
+        const runId = getCurrentRunId();
+        if (!runId) {
+            return;
+        }
+        scheduleHook('runtime:ready', {
+            runId,
+            device,
+        });
+    };
+    const onDisconnect = () => {
+        const runId = getCurrentRunId();
+        if (!runId) {
+            return;
+        }
+        scheduleHook('runtime:disconnected', {
+            runId,
+            reason: 'bridge-disconnected',
+        });
+    };
+    const onAppMonitorEvent = (event) => {
+        const runId = getCurrentRunId();
+        if (!runId) {
+            return;
+        }
+        if (event.type === 'app_started') {
+            scheduleHook('app:started', {
+                runId,
+                testFile: activeTestFilePath,
+                pid: event.pid,
+                source: event.source,
+                line: event.line,
+            });
+            return;
+        }
+        if (event.type === 'app_exited') {
+            scheduleHook('app:exited', {
+                runId,
+                testFile: activeTestFilePath,
+                pid: event.pid,
+                source: event.source,
+                line: event.line,
+                isConfirmed: event.isConfirmed,
+                crashDetails: event.crashDetails,
+            });
+            return;
+        }
+        if (event.type === 'possible_crash') {
+            scheduleHook('app:possible-crash', {
+                runId,
+                testFile: activeTestFilePath,
+                pid: event.pid,
+                source: event.source,
+                line: event.line,
+                isConfirmed: event.isConfirmed,
+                crashDetails: event.crashDetails,
+            });
+        }
+    };
+    serverBridge.on('ready', onReady);
+    serverBridge.on('disconnect', onDisconnect);
+    serverBridge.on('event', bridgeEventListener);
+    metroInstance.events.addListener(onMetroEvent);
+    appMonitor.addListener(onAppMonitorEvent);
+    harnessLogger.debug('registered runtime, bridge, and Metro listeners');
     if (config.forwardClientLogs) {
         metroInstance.events.addListener(clientLogListener);
+        harnessLogger.debug('client log forwarding enabled');
     }
-    const dispose = async () => {
+    const dispose = async (reason = 'normal') => {
+        harnessLogger.debug('disposing Harness (reason=%s)', reason);
+        let hookError;
+        try {
+            await flushPendingHooks();
+            await pluginManager.callHook('harness:before-dispose', {
+                runId: currentRun?.runId,
+                reason,
+                summary: currentRun?.summary,
+                status: currentRun?.status,
+                error: currentRun?.error,
+            });
+            await flushPendingHooks();
+        }
+        catch (error) {
+            hookError = error;
+        }
         if (config.forwardClientLogs) {
             metroInstance.events.removeListener(clientLogListener);
         }
-        serverBridge.off('ready', crashSupervisor.markReady);
+        metroInstance.events.removeListener(onMetroEvent);
+        appMonitor.removeListener(onAppMonitorEvent);
+        serverBridge.off('ready', onReady);
+        serverBridge.off('disconnect', onDisconnect);
+        serverBridge.off('event', bridgeEventListener);
         await Promise.all([
             crashSupervisor.dispose(),
             serverBridge.dispose(),
             platformInstance.dispose(),
             metroInstance.dispose(),
         ]);
+        pluginAbortController.abort();
+        harnessLogger.debug('Harness resources disposed');
+        if (hookError) {
+            throw hookError;
+        }
     };
     if (signal.aborted) {
-        await dispose();
+        await dispose('abort');
         throw new DOMException('The operation was aborted', 'AbortError');
     }
     try {
-        await prewarmMetroBundle({
-            projectRoot,
-            entryPoint: config.entryPoint,
-            platform: platform.platformId,
-            dev: true,
-            minify: false,
-            signal,
+        await pluginManager.callHook('harness:before-creation', {
+            appLaunchOptions,
         });
-        logMetroPrewarmCompleted(platform);
         await appMonitor.start();
+        harnessLogger.debug('app monitor started');
     }
     catch (error) {
-        await dispose();
+        const runState = currentRun;
+        if (runState) {
+            runState.error = error;
+            currentRun = runState;
+        }
+        await dispose(error instanceof DOMException && error.name === 'AbortError' ? 'abort' : 'error');
         throw error;
     }
     const ensureAppReady = async (testFilePath) => {
+        await flushPendingHooks();
+        setActiveTestFilePath(testFilePath);
         crashSupervisor.setActiveTestFile(testFilePath);
+        harnessLogger.debug('ensuring app is ready for %s', testFilePath);
         if (crashSupervisor.isReady() && (await platformInstance.isAppRunning())) {
+            harnessLogger.debug('reusing existing ready app for %s', testFilePath);
             return;
         }
         crashSupervisor.reset();
+        harnessLogger.debug('app not ready, waiting for launch and runtime readiness');
         await waitForAppReady({
+            metroInstance,
             serverBridge,
             platformInstance: platformInstance,
-            bridgeTimeout: config.bridgeTimeout,
+            platformId: platform.platformId,
+            bundleStartTimeout: config.bundleStartTimeout ?? 60000,
+            readyTimeout: config.bridgeTimeout,
+            maxAppRestarts: config.maxAppRestarts ?? 2,
             testFilePath,
             crashSupervisor,
             appLaunchOptions,
         });
+        await flushPendingHooks();
+        harnessLogger.debug('app is ready for %s', testFilePath);
     };
     const restart = async (testFilePath) => {
+        await flushPendingHooks();
         await crashSupervisor.stop();
+        setActiveTestFilePath(testFilePath);
+        harnessLogger.debug('restarting app (testFile=%s mode=%s)', testFilePath ?? 'n/a', testFilePath ? 'stop-and-ensure-ready' : 'direct-restart');
         if (testFilePath) {
+            harnessLogger.debug('stopping app before restart');
             await platformInstance.stopApp();
         }
         else {
+            harnessLogger.debug('requesting direct app restart');
             await platformInstance.restartApp(appLaunchOptions);
         }
         crashSupervisor.reset();
@@ -129,27 +458,44 @@ const getHarnessInternal = async (config, platform, projectRoot, signal) => {
         if (testFilePath) {
             await ensureAppReady(testFilePath);
         }
+        await flushPendingHooks();
+        harnessLogger.debug('restart completed');
     };
     return {
         context,
         runTests: async (path, options) => {
+            await flushPendingHooks();
+            activeTestFilePath = path;
             const client = serverBridge.rpc.clients.at(-1);
             if (!client) {
                 throw new Error('No client found');
             }
-            return await client.runTests(path, {
+            harnessLogger.debug('running test file on client: %s', path);
+            const result = await client.runTests(path, {
                 ...options,
                 runner: platform.runner,
             });
+            await flushPendingHooks();
+            return result;
         },
         ensureAppReady,
         restart,
-        dispose,
+        dispose: () => dispose('normal'),
         crashSupervisor,
+        callHook: async (name, payload) => {
+            await flushPendingHooks();
+            await pluginManager.callHook(name, payload);
+            await flushPendingHooks();
+        },
+        setRunState: (runState) => {
+            currentRun = runState;
+        },
+        getRunState: () => currentRun,
     };
 };
 export const getHarness = async (config, platform, projectRoot) => {
     const abortSignal = AbortSignal.timeout(config.bridgeTimeout);
+    harnessLogger.debug('creating Harness with bridge timeout %dms', config.bridgeTimeout);
     try {
         const harness = await getHarnessInternal(config, platform, projectRoot, abortSignal);
         return harness;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,MAAM,EACN,aAAa,EACb,WAAW,EACX,aAAa,EACb,IAAI,EACJ,iBAAiB,EACjB,WAAW,EACZ,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAe5C,MAAM,CAAC,OAAO,OAAO,WAAY,YAAW,2BAA2B;;IACrE,QAAQ,CAAC,QAAQ,QAAQ;gBAIb,YAAY,EAAE,MAAM,CAAC,YAAY;IAIvC,QAAQ,CACZ,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC;IAkCV,oBAAoB,CACxB,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,IAAI,CAAC;CAgFjB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,2BAA2B,EAC3B,MAAM,EACN,aAAa,EACb,WAAW,EACX,aAAa,EACb,IAAI,EACJ,iBAAiB,EACjB,WAAW,EACZ,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,KAAK,OAAO,EAAwB,MAAM,cAAc,CAAC;AA0ClE,MAAM,CAAC,OAAO,OAAO,WAAY,YAAW,2BAA2B;;IACrE,QAAQ,CAAC,QAAQ,QAAQ;gBAIb,YAAY,EAAE,MAAM,CAAC,YAAY;IAIvC,QAAQ,CACZ,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC;IAkCV,oBAAoB,CACxB,KAAK,EAAE,KAAK,CAAC,IAAI,CAAC,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,WAAW,EACpB,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,IAAI,CAAC;CAyQjB"}