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

package/dist/__tests__/resource-lock.test.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { createResourceLockManager, hashResourceLockKey, } from '../resource-lock.js';
+import { createResourceLockManager } from '../resource-lock.js';
 describe('resource lock manager', () => {
     let rootDir;
     beforeEach(async () => {
@@ -54,10 +54,11 @@ describe('resource lock manager', () => {
         await expect(acquirePromise).rejects.toMatchObject({
             name: 'AbortError',
         });
-        const queueDir = path.join(rootDir, hashResourceLockKey(key), 'queue');
-        const queuedEntries = await fs.readdir(queueDir);
-        expect(queuedEntries).toHaveLength(0);
+        // The aborted waiter must have cleaned up its ticket. Verify by releasing
+        // the first lock and confirming a fresh acquire completes immediately.
         await firstLease.release();
+        const cleanupLease = await manager.acquire(key);
+        await cleanupLease.release();
     });
     it('keeps queued tickets alive while the waiting process is still active', async () => {
         const manager = createResourceLockManager({
@@ -76,29 +77,27 @@ describe('resource lock manager', () => {
         await secondLease.release();
     });
     it('reclaims a stale owner before granting the lock', async () => {
-        const manager = createResourceLockManager({
+        const key = 'web:browser:chromium';
+        // Simulate a live process holding the lock.
+        const manager1 = createResourceLockManager({
+            rootDir,
+            pollIntervalMs: 5,
+            heartbeatIntervalMs: 20,
+        });
+        const staleLease = await manager1.acquire(key);
+        // A second manager whose isProcessActive always returns false will consider
+        // any owner — including the live one above — immediately stale and reclaim it.
+        const manager2 = createResourceLockManager({
             rootDir,
             pollIntervalMs: 5,
             heartbeatIntervalMs: 20,
             staleLockTimeoutMs: 50,
             isProcessActive: () => false,
         });
-        const key = 'web:browser:chromium';
-        const keyDir = path.join(rootDir, hashResourceLockKey(key));
-        const queueDir = path.join(keyDir, 'queue');
-        const ownerFilePath = path.join(keyDir, 'owner.json');
-        await fs.mkdir(queueDir, { recursive: true });
-        await fs.writeFile(ownerFilePath, JSON.stringify({
-            ticketId: 'stale-owner',
-            key,
-            pid: 999999,
-            createdAt: Date.now() - 1000,
-            heartbeatAt: Date.now() - 1000,
-        }), 'utf8');
-        const lease = await manager.acquire(key);
-        const owner = JSON.parse(await fs.readFile(ownerFilePath, 'utf8'));
-        expect(owner.ticketId).not.toBe('stale-owner');
+        const lease = await manager2.acquire(key);
         await lease.release();
+        // manager1 was evicted; its release is best-effort.
+        await staleLease.release();
     });
     it('keeps owner metadata valid when heartbeat writes overlap', async () => {
         const manager = createResourceLockManager({
@@ -108,20 +107,21 @@ describe('resource lock manager', () => {
             staleLockTimeoutMs: 200,
         });
         const key = 'ios:simulator:iPhone 17 Pro:26.2';
-        const ownerFilePath = path.join(rootDir, hashResourceLockKey(key), 'owner.json');
         const actualWriteFile = fs.writeFile.bind(fs);
         const writeFileSpy = vi
             .spyOn(fs, 'writeFile')
             .mockImplementation(async (file, data, options) => {
-            if (typeof file === 'string' &&
-                file.startsWith(ownerFilePath) &&
-                file !== ownerFilePath) {
+            // Delay atomic temp-file writes to simulate overlapping heartbeat flushes.
+            if (typeof file === 'string' && file.startsWith(rootDir) && file.endsWith('.tmp')) {
                 await new Promise((resolve) => setTimeout(resolve, 25));
             }
             return await actualWriteFile(file, data, options);
         });
         try {
             const lease = await manager.acquire(key);
+            // Discover the owner file after acquire creates the key directory.
+            const [keyDirName] = await fs.readdir(rootDir);
+            const ownerFilePath = path.join(rootDir, keyDirName, 'owner.json');
             const initialOwner = JSON.parse(await fs.readFile(ownerFilePath, 'utf8'));
             await new Promise((resolve) => setTimeout(resolve, 80));
             for (let index = 0; index < 5; index += 1) {

package/dist/client-log-handler.d.ts

@@ -1,23 +1,22 @@
 import type { ReportableEvent } from '@react-native-harness/bundler-metro';
+import type { TestResult as JestTestResult } from '@jest/test-result';
 export type ClientLogEvent = Extract<ReportableEvent, {
     type: 'client_log';
 }>;
+export type ClientLogBuffer = NonNullable<JestTestResult['console']>;
+export type ClientLogEntry = ClientLogBuffer[number];
+export type ClientLogCollector = {
+    handleEvent: (event: ReportableEvent) => void;
+    flush: () => ClientLogBuffer;
+};
 /**
  * Formats a client log event data array into a string message.
  * Uses util.format for printf-style format specifier support (%s, %d, %j, etc.)
  */
 export declare const formatClientLogMessage: (data: unknown[]) => string;
 /**
- * Formats a client log event into a log line with styled level prefix.
+ * Formats a client log event into Jest's buffered console entry format.
  */
-export declare const formatClientLogLine: (event: ClientLogEvent) => string;
-/**
- * Handles a client_log event by formatting and logging it.
- * Returns true if the event was handled, false otherwise.
- */
-export declare const handleClientLogEvent: (event: ReportableEvent) => boolean;
-/**
- * Creates a client log event listener that can be added to the Metro reporter.
- */
-export declare const createClientLogListener: () => ((event: ReportableEvent) => void);
+export declare const formatClientLogEntry: (event: ClientLogEvent) => ClientLogEntry | null;
+export declare const createClientLogCollector: () => ClientLogCollector;
 //# sourceMappingURL=client-log-handler.d.ts.map

package/dist/client-log-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client-log-handler.d.ts","sourceRoot":"","sources":["../src/client-log-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAK3E,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC;AA6C9E;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,OAAO,EAAE,KAAG,MAKxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,cAAc,KAAG,MAI3D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,eAAe,KAAG,OAiB7D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,QAAO,CAAC,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAI3E,CAAC"}
+{"version":3,"file":"client-log-handler.d.ts","sourceRoot":"","sources":["../src/client-log-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAC3E,OAAO,KAAK,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGtE,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC;AAC9E,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,CAAC;AACrE,MAAM,MAAM,cAAc,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;AACrD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,WAAW,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IAC9C,KAAK,EAAE,MAAM,eAAe,CAAC;CAC9B,CAAC;AAuBF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,OAAO,EAAE,KAAG,MAMxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,cAAc,KACpB,cAAc,GAAG,IAYnB,CAAC;AAEF,eAAO,MAAM,wBAAwB,QAAO,kBAoB3C,CAAC"}

package/dist/client-log-handler.js

@@ -1,41 +1,19 @@
-import chalk from 'chalk';
 import util from 'node:util';
-import { log } from './logs.js';
 /**
- * Gets the display level for a log level.
+ * Gets the Jest console level for a client log level.
  * Note: Metro treats 'trace' as 'log' because Hermes doesn't include stack traces.
  */
-const getDisplayLevel = (level) => {
-    // Metro converts trace to log for display (Hermes doesn't provide stack traces)
-    if (level === 'trace') {
-        return 'LOG';
-    }
-    return level.toUpperCase();
-};
-/**
- * Creates a styled tag for a log level with colored box appearance.
- */
-const createLevelTag = (level) => {
-    const displayLevel = getDisplayLevel(level);
-    const label = ` ${displayLevel} `;
-    if (!chalk.supportsColor) {
-        return `[${displayLevel}]`;
-    }
+const getJestLogLevel = (level) => {
     switch (level) {
-        case 'error':
-            return chalk.reset.inverse.bold.red(label);
-        case 'warn':
-            return chalk.reset.inverse.bold.yellow(label);
-        case 'info':
-            return chalk.reset.inverse.bold.cyan(label);
-        case 'debug':
-            return chalk.reset.inverse.bold.blue(label);
+        case 'group':
+        case 'groupCollapsed':
+        case 'groupEnd':
+            return null;
         case 'trace':
-            // Trace displays as LOG but with a distinct color
-            return chalk.reset.inverse.bold.magenta(label);
+            return 'log';
         case 'log':
         default:
-            return chalk.reset.inverse.bold.white(label);
+            return level;
     }
 };
 /**
@@ -49,36 +27,36 @@ export const formatClientLogMessage = (data) => {
     return util.format(...data);
 };
 /**
- * Formats a client log event into a log line with styled level prefix.
- */
-export const formatClientLogLine = (event) => {
-    const tag = createLevelTag(event.level);
-    const message = formatClientLogMessage(event.data);
-    return `${tag} ${message}`;
-};
-/**
- * Handles a client_log event by formatting and logging it.
- * Returns true if the event was handled, false otherwise.
+ * Formats a client log event into Jest's buffered console entry format.
  */
-export const handleClientLogEvent = (event) => {
-    if (event.type !== 'client_log') {
-        return false;
+export const formatClientLogEntry = (event) => {
+    const logLevel = getJestLogLevel(event.level);
+    if (!logLevel) {
+        return null;
     }
-    // Skip group events - they don't produce output
-    if (event.level === 'group' ||
-        event.level === 'groupCollapsed' ||
-        event.level === 'groupEnd') {
-        return true;
-    }
-    const logLine = formatClientLogLine(event);
-    log(logLine);
-    return true;
+    const message = formatClientLogMessage(event.data);
+    return {
+        message,
+        origin: '',
+        type: logLevel,
+    };
 };
-/**
- * Creates a client log event listener that can be added to the Metro reporter.
- */
-export const createClientLogListener = () => {
-    return (event) => {
-        handleClientLogEvent(event);
+export const createClientLogCollector = () => {
+    let buffer = [];
+    return {
+        handleEvent: (event) => {
+            if (event.type !== 'client_log') {
+                return;
+            }
+            const entry = formatClientLogEntry(event);
+            if (entry) {
+                buffer.push(entry);
+            }
+        },
+        flush: () => {
+            const flushed = buffer;
+            buffer = [];
+            return flushed;
+        },
     };
 };

package/dist/crash-monitor.d.ts

@@ -1,16 +1,23 @@
-import { HarnessPlatformRunner } from '@react-native-harness/platforms';
-import { BridgeServer } from '@react-native-harness/bridge/server';
+import { type AppMonitor, type HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { type NativeCrashPhase } from './errors.js';
+export declare class CrashWatchCancelledError extends Error {
+    constructor();
+}
+export type CrashWatch = {
+    readonly promise: Promise<never>;
+    cancel: () => void;
+};
 export type CrashMonitor = {
-    startMonitoring(testFilePath: string): Promise<never>;
-    stopMonitoring(): void;
-    markIntentionalRestart(): void;
-    clearIntentionalRestart(): void;
-    dispose(): void;
+    watch: (testFilePath: string, phase: NativeCrashPhase) => CrashWatch;
+    isAlive: () => boolean;
+    stop: () => Promise<void>;
+    start: () => Promise<void>;
+    reset: () => void;
+    dispose: () => Promise<void>;
 };
 export type CrashMonitorOptions = {
-    interval: number;
+    appMonitor: AppMonitor;
     platformRunner: HarnessPlatformRunner;
-    bridgeServer: BridgeServer;
 };
-export declare const createCrashMonitor: ({ interval, platformRunner, bridgeServer, }: CrashMonitorOptions) => CrashMonitor;
+export declare const createCrashMonitor: ({ appMonitor, platformRunner, }: CrashMonitorOptions) => CrashMonitor;
 //# sourceMappingURL=crash-monitor.d.ts.map

package/dist/crash-monitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crash-monitor.d.ts","sourceRoot":"","sources":["../src/crash-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAInE,MAAM,MAAM,YAAY,GAAG;IACzB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IACtD,cAAc,IAAI,IAAI,CAAC;IACvB,sBAAsB,IAAI,IAAI,CAAC;IAC/B,uBAAuB,IAAI,IAAI,CAAC;IAChC,OAAO,IAAI,IAAI,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,qBAAqB,CAAC;IACtC,YAAY,EAAE,YAAY,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,6CAIhC,mBAAmB,KAAG,YAqFxB,CAAC"}
+{"version":3,"file":"crash-monitor.d.ts","sourceRoot":"","sources":["../src/crash-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAIf,KAAK,qBAAqB,EAC3B,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,aAAa,CAAC;AAKrB,qBAAa,wBAAyB,SAAQ,KAAK;;CAKlD;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACjC,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,KAAK,UAAU,CAAC;IACrE,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,qBAAqB,CAAC;CACvC,CAAC;AA6BF,eAAO,MAAM,kBAAkB,GAAI,iCAGhC,mBAAmB,KAAG,YA+KxB,CAAC"}

package/dist/crash-monitor.js

@@ -1,75 +1,176 @@
-import { NativeCrashError } from './errors.js';
+import { NativeCrashError, } from './errors.js';
 import { logger } from '@react-native-harness/tools';
-export const createCrashMonitor = ({ interval, platformRunner, bridgeServer, }) => {
-    let pollingInterval = null;
-    let isIntentionalRestart = false;
-    let currentTestFilePath = null;
-    let rejectFn = null;
-    const handleDisconnect = () => {
-        // Verify if it's actually a crash by checking if app is still running
-        if (!isIntentionalRestart && currentTestFilePath) {
-            // Capture the value to avoid it being null when setTimeout callback runs
-            const testFilePath = currentTestFilePath;
-            logger.debug('Bridge disconnected, checking if app crashed');
-            // Use a slight delay to allow the OS to clean up the process
-            setTimeout(async () => {
-                const isRunning = await platformRunner.isAppRunning();
-                if (!isRunning && !isIntentionalRestart && rejectFn) {
-                    logger.debug(`Native crash detected during: ${testFilePath}`);
-                    rejectFn(new NativeCrashError(testFilePath));
-                }
-            }, 100);
+const crashLogger = logger.child('crash');
+export class CrashWatchCancelledError extends Error {
+    constructor() {
+        super('Crash watch was cancelled');
+        this.name = 'CrashWatchCancelledError';
+    }
+}
+const mergeCrashDetails = (phase, initial, enriched, fallbackSummary) => ({
+    phase,
+    source: enriched?.source ?? initial?.source,
+    summary: enriched?.summary ?? initial?.summary ?? fallbackSummary,
+    signal: enriched?.signal ?? initial?.signal,
+    exceptionType: enriched?.exceptionType ?? initial?.exceptionType,
+    processName: enriched?.processName ?? initial?.processName,
+    pid: enriched?.pid ?? initial?.pid,
+    stackTrace: enriched?.stackTrace ?? initial?.stackTrace,
+    rawLines: enriched?.rawLines ?? initial?.rawLines,
+    artifactType: enriched?.artifactType ?? initial?.artifactType,
+    artifactPath: enriched?.artifactPath ?? initial?.artifactPath,
+});
+export const createCrashMonitor = ({ appMonitor, platformRunner, }) => {
+    let alive = false;
+    let monitoring = true;
+    let isResolvingCrash = false;
+    let disposed = false;
+    // Both updated when watch() is called so crashes are attributed to the
+    // correct test file and lifecycle phase.
+    let currentTestFilePath = '';
+    let currentPhase = 'startup';
+    const watchers = new Set();
+    const getCrashDetailsProvider = () => {
+        if ('getCrashDetails' in appMonitor) {
+            return appMonitor;
         }
+        if (platformRunner.getCrashDetails) {
+            return platformRunner;
+        }
+        return null;
     };
-    const startMonitoring = (testFilePath) => {
-        currentTestFilePath = testFilePath;
-        return new Promise((_, reject) => {
-            rejectFn = reject;
-            // Listen for bridge disconnect as early indicator
-            bridgeServer.on('disconnect', handleDisconnect);
-            // Poll for app running status
-            pollingInterval = setInterval(async () => {
-                // Skip check during intentional restarts
-                if (isIntentionalRestart) {
-                    return;
-                }
-                try {
-                    const isRunning = await platformRunner.isAppRunning();
-                    if (!isRunning && currentTestFilePath) {
-                        logger.debug(`Native crash detected during: ${currentTestFilePath}`);
-                        stopMonitoring();
-                        reject(new NativeCrashError(currentTestFilePath));
-                    }
-                }
-                catch (error) {
-                    logger.error('Error checking app status:', error);
-                }
-            }, interval);
-        });
+    const notifyCrash = (err) => {
+        const pending = [...watchers];
+        watchers.clear();
+        for (const fn of pending)
+            fn(err);
     };
-    const stopMonitoring = () => {
-        if (pollingInterval) {
-            clearInterval(pollingInterval);
-            pollingInterval = null;
+    const handleCrash = async (phase, details, fallbackSummary) => {
+        if (isResolvingCrash)
+            return;
+        isResolvingCrash = true;
+        alive = false;
+        crashLogger.debug('native crash detected (phase=%s)', phase);
+        for (const line of details?.rawLines ?? []) {
+            crashLogger.debug('%s', line);
+        }
+        try {
+            const enriched = await getCrashDetailsProvider()?.getCrashDetails?.({
+                processName: details?.processName,
+                pid: details?.pid,
+                occurredAt: Date.now(),
+            });
+            const merged = mergeCrashDetails(phase, details, enriched, fallbackSummary);
+            crashLogger.debug('crash details: %o', {
+                phase: merged.phase,
+                source: merged.source,
+                summary: merged.summary,
+                signal: merged.signal,
+                exceptionType: merged.exceptionType,
+                processName: merged.processName,
+                pid: merged.pid,
+            });
+            notifyCrash(new NativeCrashError(currentTestFilePath, merged));
+        }
+        finally {
+            isResolvingCrash = false;
         }
-        bridgeServer.off('disconnect', handleDisconnect);
-        currentTestFilePath = null;
-        rejectFn = null;
     };
-    const markIntentionalRestart = () => {
-        isIntentionalRestart = true;
+    const confirmAndHandleCrash = async (phase, details, fallbackSummary) => {
+        if (disposed || !monitoring)
+            return;
+        try {
+            const isRunning = await platformRunner.isAppRunning();
+            if (!isRunning) {
+                void handleCrash(phase, details, fallbackSummary);
+            }
+        }
+        catch (error) {
+            crashLogger.debug('crash confirmation failed', error);
+        }
     };
-    const clearIntentionalRestart = () => {
-        isIntentionalRestart = false;
+    const extractCrashDetails = (event) => event.crashDetails
+        ? {
+            source: event.crashDetails.source ?? event.source,
+            summary: event.crashDetails.summary,
+            signal: event.crashDetails.signal,
+            exceptionType: event.crashDetails.exceptionType,
+            processName: event.crashDetails.processName,
+            pid: event.crashDetails.pid ?? event.pid,
+            stackTrace: event.crashDetails.stackTrace,
+            rawLines: event.crashDetails.rawLines ??
+                (event.line ? [event.line] : undefined),
+        }
+        : undefined;
+    const appMonitorListener = (event) => {
+        if (disposed || !monitoring)
+            return;
+        if (event.type === 'app_started') {
+            alive = true;
+            return;
+        }
+        if (event.type === 'app_exited') {
+            const details = extractCrashDetails(event);
+            if (event.isConfirmed ?? event.source === 'polling') {
+                void handleCrash(currentPhase, details);
+            }
+            else {
+                void confirmAndHandleCrash(currentPhase, details);
+            }
+            return;
+        }
+        if (event.type === 'possible_crash') {
+            const details = extractCrashDetails(event);
+            const fallback = `possible crash signal (${event.source ?? 'unknown'})`;
+            if (event.isConfirmed) {
+                void handleCrash(currentPhase, details, fallback);
+            }
+            else {
+                void confirmAndHandleCrash(currentPhase, details, fallback);
+            }
+        }
     };
-    const dispose = () => {
-        stopMonitoring();
+    appMonitor.addListener(appMonitorListener);
+    const watch = (testFilePath, phase) => {
+        currentTestFilePath = testFilePath;
+        currentPhase = phase;
+        let rejectFn;
+        const promise = new Promise((_, reject) => {
+            rejectFn = (err) => {
+                watchers.delete(rejectFn);
+                reject(err);
+            };
+            watchers.add(rejectFn);
+        });
+        const cancel = () => {
+            rejectFn(new CrashWatchCancelledError());
+        };
+        return { promise, cancel };
     };
     return {
-        startMonitoring,
-        stopMonitoring,
-        markIntentionalRestart,
-        clearIntentionalRestart,
-        dispose,
+        watch,
+        isAlive: () => alive,
+        stop: async () => {
+            monitoring = false;
+            await appMonitor.stop();
+        },
+        start: async () => {
+            monitoring = true;
+            await appMonitor.start();
+        },
+        reset: () => {
+            alive = false;
+            watchers.clear();
+            isResolvingCrash = false;
+            currentTestFilePath = '';
+        },
+        dispose: async () => {
+            disposed = true;
+            monitoring = false;
+            watchers.clear();
+            isResolvingCrash = false;
+            appMonitor.removeListener(appMonitorListener);
+            await appMonitor.dispose();
+        },
     };
 };

package/dist/execute-run.d.ts

@@ -0,0 +1,4 @@
+import type { OnTestFailure, OnTestStart, OnTestSuccess, Test, TestWatcher, Config } 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>;
+//# sourceMappingURL=execute-run.d.ts.map

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

@@ -0,0 +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"}