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

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"}

package/dist/index.js

@@ -5,7 +5,23 @@ import { teardown } from './teardown.js';
 import { HarnessError } from '@react-native-harness/tools';
 import { getErrorMessage } from './logs.js';
 import { DeviceNotRespondingError } from '@react-native-harness/bridge/server';
-import { NativeCrashError } from './errors.js';
+import { NativeCrashError, StartupStallError } from './errors.js';
+import { logger } from '@react-native-harness/tools';
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+const runLogger = logger.child('run');
+const createRunSummary = () => ({
+    passed: 0,
+    failed: 0,
+    skipped: 0,
+    todo: 0,
+});
+const applyJestResultToSummary = (summary, result) => {
+    summary.passed += result.numPassingTests;
+    summary.failed += result.numFailingTests;
+    summary.skipped += result.numPendingTests;
+    summary.todo += result.numTodoTests;
+};
 class CancelRun extends Error {
     constructor(message) {
         super(message);
@@ -44,64 +60,195 @@ export default class JestHarness {
     async _createInBandTestRun(tests, watcher, harness, harnessConfig, onStart, onResult, onFailure) {
         const mutex = pLimit(1);
         let isFirstTest = true;
-        return tests.reduce((promise, test) => mutex(() => promise
-            .then(async () => {
-            if (watcher.isInterrupted()) {
-                throw new CancelRun();
-            }
-            if (harnessConfig.resetEnvironmentBetweenTestFiles &&
-                !isFirstTest) {
-                await harness.restart(test.path);
-            }
-            isFirstTest = false;
-            return onStart(test).then(async () => {
-                if (!harnessConfig.detectNativeCrashes) {
-                    await harness.ensureAppReady(test.path);
-                    return runHarnessTestFile({
-                        testPath: test.path,
-                        harness,
-                        globalConfig: this.#globalConfig,
-                        projectConfig: test.context.config,
+        const startTime = Date.now();
+        const runId = randomUUID();
+        const watchMode = this.#globalConfig.watch || this.#globalConfig.watchAll;
+        const rootDir = this.#globalConfig.rootDir ?? process.cwd();
+        const testFiles = tests.map((test) => path.relative(rootDir, test.path));
+        const summary = createRunSummary();
+        const updateRunState = (overrides = {}) => {
+            const nextRunState = {
+                runId,
+                startTime,
+                testFiles,
+                watchMode,
+                coverageEnabled: this.#globalConfig.collectCoverage,
+                summary,
+                status: summary.failed > 0 ? 'failed' : 'passed',
+                ...overrides,
+            };
+            harness.setRunState(nextRunState);
+            return nextRunState;
+        };
+        updateRunState();
+        runLogger.debug('run started: runId=%s files=%d watchMode=%s coverage=%s', runId, testFiles.length, watchMode, this.#globalConfig.collectCoverage);
+        await harness.callHook('run:started', {
+            runId,
+            startTime,
+            testFiles,
+            watchMode,
+            coverageEnabled: this.#globalConfig.collectCoverage,
+        });
+        await harness.callHook('metro:initialized', {
+            runId,
+            port: harnessConfig.metroPort,
+            host: harnessConfig.host?.trim() || undefined,
+        });
+        try {
+            await tests.reduce((promise, test) => mutex(() => {
+                let didApplySummary = false;
+                return promise
+                    .then(async () => {
+                    const relativeTestPath = path.relative(rootDir, test.path);
+                    const testFileStartedAt = Date.now();
+                    let didEmitTestFileFinished = false;
+                    await harness.callHook('test-file:started', {
+                        runId,
+                        file: relativeTestPath,
                     });
-                }
-                await harness.ensureAppReady(test.path);
-                harness.crashSupervisor.beginTestRun(test.path);
-                const crashPromise = harness.crashSupervisor.waitForCrash(test.path);
-                try {
-                    const result = await Promise.race([
-                        runHarnessTestFile({
-                            testPath: test.path,
-                            harness,
-                            globalConfig: this.#globalConfig,
-                            projectConfig: test.context.config,
-                        }),
-                        crashPromise,
-                    ]);
-                    return result;
-                }
-                finally {
-                    harness.crashSupervisor.cancelCrashWaiters();
-                }
-            });
-        })
-            .then((result) => onResult(test, result))
-            .catch(async (err) => {
-            if (err instanceof NativeCrashError) {
-                harness.crashSupervisor.reset();
-                onFailure(test, {
-                    message: err.message,
-                    stack: '',
+                    runLogger.debug('test file started: %s', relativeTestPath);
+                    const emitTestFileFinished = async (options) => {
+                        didEmitTestFileFinished = true;
+                        runLogger.debug('test file finished: %s status=%s duration=%dms', relativeTestPath, options.status, options.duration);
+                        await harness.callHook('test-file:finished', {
+                            runId,
+                            file: relativeTestPath,
+                            duration: options.duration,
+                            status: options.status,
+                            result: options.result,
+                        });
+                    };
+                    try {
+                        if (watcher.isInterrupted()) {
+                            throw new CancelRun();
+                        }
+                        if (harnessConfig.resetEnvironmentBetweenTestFiles &&
+                            !isFirstTest) {
+                            runLogger.debug('resetting environment before %s', relativeTestPath);
+                            await harness.restart(test.path);
+                        }
+                        isFirstTest = false;
+                        const result = await onStart(test).then(async () => {
+                            if (!harnessConfig.detectNativeCrashes) {
+                                runLogger.debug('native crash detection disabled for %s', relativeTestPath);
+                                await harness.ensureAppReady(test.path);
+                                return runHarnessTestFile({
+                                    testPath: test.path,
+                                    harness,
+                                    globalConfig: this.#globalConfig,
+                                    projectConfig: test.context.config,
+                                });
+                            }
+                            await harness.ensureAppReady(test.path);
+                            harness.crashSupervisor.beginTestRun(test.path);
+                            runLogger.debug('native crash detection armed for %s', relativeTestPath);
+                            const crashPromise = harness.crashSupervisor.waitForCrash(test.path);
+                            try {
+                                return await Promise.race([
+                                    runHarnessTestFile({
+                                        testPath: test.path,
+                                        harness,
+                                        globalConfig: this.#globalConfig,
+                                        projectConfig: test.context.config,
+                                    }),
+                                    crashPromise,
+                                ]);
+                            }
+                            finally {
+                                harness.crashSupervisor.cancelCrashWaiters();
+                            }
+                        });
+                        applyJestResultToSummary(summary, result.jestResult);
+                        didApplySummary = true;
+                        updateRunState();
+                        await emitTestFileFinished({
+                            status: result.harnessResult.status,
+                            duration: result.duration,
+                            result: result.harnessResult,
+                        });
+                        return result;
+                    }
+                    catch (error) {
+                        if (!didEmitTestFileFinished) {
+                            await emitTestFileFinished({
+                                status: 'failed',
+                                duration: Date.now() - testFileStartedAt,
+                                result: null,
+                            });
+                        }
+                        throw error;
+                    }
+                })
+                    .then(async (result) => {
+                    if (!result) {
+                        return;
+                    }
+                    await onResult(test, result.jestResult);
+                })
+                    .catch(async (err) => {
+                    if (err instanceof NativeCrashError ||
+                        err instanceof StartupStallError ||
+                        err instanceof DeviceNotRespondingError) {
+                        runLogger.debug('classified runtime failure for %s: %s', test.path, err.name);
+                        summary.failed += 1;
+                        updateRunState();
+                    }
+                    if (err instanceof NativeCrashError) {
+                        harness.crashSupervisor.reset();
+                        onFailure(test, {
+                            message: err.message,
+                            stack: '',
+                        });
+                        return;
+                    }
+                    if (err instanceof StartupStallError) {
+                        onFailure(test, {
+                            message: err.message,
+                            stack: '',
+                        });
+                        return;
+                    }
+                    if (err instanceof DeviceNotRespondingError) {
+                        onFailure(test, {
+                            message: err.message,
+                            stack: '',
+                        });
+                        return;
+                    }
+                    if (!(err instanceof CancelRun) && !didApplySummary) {
+                        summary.failed += 1;
+                    }
+                    updateRunState({ error: err });
+                    onFailure(test, err);
                 });
-                return;
-            }
-            if (err instanceof DeviceNotRespondingError) {
-                onFailure(test, {
-                    message: err.message,
-                    stack: '',
-                });
-                return;
-            }
-            onFailure(test, err);
-        })), Promise.resolve());
+            }), Promise.resolve());
+            const runState = updateRunState();
+            runLogger.debug('run finished: runId=%s status=%s duration=%dms', runId, runState.status ?? 'passed', Date.now() - startTime);
+            await harness.callHook('run:finished', {
+                runId,
+                startTime,
+                duration: Date.now() - startTime,
+                testFiles,
+                summary,
+                status: runState.status ?? 'passed',
+            });
+        }
+        catch (error) {
+            const runState = updateRunState({
+                error,
+                status: 'failed',
+            });
+            runLogger.debug('run failed: runId=%s status=%s', runId, runState.status ?? 'failed');
+            await harness.callHook('run:finished', {
+                runId,
+                startTime,
+                duration: Date.now() - startTime,
+                testFiles,
+                summary,
+                status: runState.status ?? 'failed',
+                error,
+            });
+            throw error;
+        }
     }
 }

package/dist/logs.d.ts

@@ -3,6 +3,10 @@ import { HarnessError } from '@react-native-harness/tools';
 export declare const log: (message: string) => void;
 export declare const logTestRunHeader: (runner: HarnessPlatform) => void;
 export declare const logTestEnvironmentReady: (runner: HarnessPlatform) => void;
+export declare const logRunnerWaitingInQueue: (runner: HarnessPlatform) => void;
+export declare const logRunnerStillWaitingInQueue: (runner: HarnessPlatform) => void;
+export declare const logRunnerStarting: (runner: HarnessPlatform) => void;
 export declare const logMetroPrewarmCompleted: (runner: HarnessPlatform) => void;
+export declare const logMetroCacheReused: (runner: HarnessPlatform) => void;
 export declare const getErrorMessage: (error: HarnessError) => string;
 //# sourceMappingURL=logs.d.ts.map

package/dist/logs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../src/logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAY3D,eAAO,MAAM,GAAG,GAAI,SAAS,MAAM,KAAG,IAErC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,eAAe,KAAG,IAI1D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,eAAe,KAAG,IAEjE,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,eAAe,KAAG,IAIlE,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,YAAY,KAAG,MAErD,CAAC"}
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../src/logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAY3D,eAAO,MAAM,GAAG,GAAI,SAAS,MAAM,KAAG,IAErC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,QAAQ,eAAe,KAAG,IAI1D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,eAAe,KAAG,IAEjE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,QAAQ,eAAe,KAAG,IAEjE,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,QAAQ,eAAe,KAAG,IAEtE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,eAAe,KAAG,IAE3D,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,eAAe,KAAG,IAElE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,QAAQ,eAAe,KAAG,IAE7D,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,OAAO,YAAY,KAAG,MAErD,CAAC"}

package/dist/logs.js

@@ -15,9 +15,21 @@ export const logTestRunHeader = (runner) => {
 export const logTestEnvironmentReady = (runner) => {
     log(`${TAG} Runner ${chalk.bold(runner.name)} ready\n`);
 };
+export const logRunnerWaitingInQueue = (runner) => {
+    log(`${TAG} Runner ${chalk.bold(runner.name)} is busy, waiting in queue\n`);
+};
+export const logRunnerStillWaitingInQueue = (runner) => {
+    log(`${TAG} Still waiting in queue for ${chalk.bold(runner.name)} runner\n`);
+};
+export const logRunnerStarting = (runner) => {
+    log(`${TAG} Runner ${chalk.bold(runner.name)} is starting\n`);
+};
 export const logMetroPrewarmCompleted = (runner) => {
     log(`${TAG} Metro pre-warm for ${chalk.bold(runner.name)} completed\n`);
 };
+export const logMetroCacheReused = (runner) => {
+    log(`${TAG} Reusing Metro cache for ${chalk.bold(runner.name)}\n`);
+};
 export const getErrorMessage = (error) => {
     return `${ERROR_TAG} ${error.message}\n`;
 };

package/dist/resource-lock.d.ts

@@ -0,0 +1,25 @@
+import { type HarnessLogger } from '@react-native-harness/tools';
+export type ResourceLockAcquireOptions = {
+    signal?: AbortSignal;
+    onWait?: () => void;
+    onStillWaiting?: (elapsedMs: number) => void;
+};
+export type ResourceLease = {
+    release: () => Promise<void>;
+};
+export type ResourceLockManager = {
+    acquire: (key: string, options?: ResourceLockAcquireOptions) => Promise<ResourceLease>;
+};
+type ResourceLockManagerOptions = {
+    rootDir?: string;
+    pollIntervalMs?: number;
+    heartbeatIntervalMs?: number;
+    staleLockTimeoutMs?: number;
+    pid?: number;
+    logger?: HarnessLogger;
+    isProcessActive?: (pid: number) => boolean;
+};
+export declare const hashResourceLockKey: (key: string) => string;
+export declare const createResourceLockManager: (options?: ResourceLockManagerOptions) => ResourceLockManager;
+export {};
+//# sourceMappingURL=resource-lock.d.ts.map

package/dist/resource-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-lock.d.ts","sourceRoot":"","sources":["../src/resource-lock.ts"],"names":[],"mappings":"AAIA,OAAO,EAAU,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAiBzE,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,CACP,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,0BAA0B,KACjC,OAAO,CAAC,aAAa,CAAC,CAAC;CAC7B,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C,CAAC;AAgBF,eAAO,MAAM,mBAAmB,GAAI,KAAK,MAAM,KAAG,MAEjD,CAAC;AAoOF,eAAO,MAAM,yBAAyB,GACpC,UAAS,0BAA+B,KACvC,mBA2JF,CAAC"}

package/dist/resource-lock.js

@@ -0,0 +1,278 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { logger } from '@react-native-harness/tools';
+const resourceLockLogger = logger.child('resource-lock');
+const DEFAULT_ROOT_DIR = path.join(os.tmpdir(), 'react-native-harness-locks');
+const DEFAULT_POLL_INTERVAL_MS = 1000;
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 2000;
+const DEFAULT_STALE_LOCK_TIMEOUT_MS = 15000;
+const wait = async (ms) => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+};
+const createAbortError = () => new DOMException('The operation was aborted', 'AbortError');
+export const hashResourceLockKey = (key) => {
+    return crypto.createHash('sha256').update(key).digest('hex');
+};
+const getPathsForKey = (rootDir, key) => {
+    const keyDir = path.join(rootDir, hashResourceLockKey(key));
+    return {
+        rootDir,
+        keyDir,
+        queueDir: path.join(keyDir, 'queue'),
+        ownerFilePath: path.join(keyDir, 'owner.json'),
+    };
+};
+const createTicketId = (createdAt, pid) => {
+    return `${createdAt
+        .toString()
+        .padStart(16, '0')}-${pid}-${crypto.randomUUID()}`;
+};
+const isMissingFileError = (error) => {
+    return (error instanceof Error &&
+        'code' in error &&
+        typeof error.code === 'string' &&
+        error.code === 'ENOENT');
+};
+const isExclusiveCreateError = (error) => {
+    return (error instanceof Error &&
+        'code' in error &&
+        typeof error.code === 'string' &&
+        error.code === 'EEXIST');
+};
+const ensureLockDirectories = async (paths) => {
+    await fs.mkdir(paths.queueDir, { recursive: true });
+};
+const readJsonFile = async (filePath) => {
+    try {
+        const content = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return null;
+        }
+        throw error;
+    }
+};
+const removeFileIfPresent = async (filePath) => {
+    try {
+        await fs.rm(filePath, { force: true });
+    }
+    catch (error) {
+        if (!isMissingFileError(error)) {
+            throw error;
+        }
+    }
+};
+const isPidActive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return !(error instanceof Error &&
+            'code' in error &&
+            typeof error.code === 'string' &&
+            error.code === 'ESRCH');
+    }
+};
+const isMetadataStale = (metadata, now, staleLockTimeoutMs, isProcessActive) => {
+    if (!isProcessActive(metadata.pid)) {
+        return true;
+    }
+    return now - metadata.heartbeatAt > staleLockTimeoutMs;
+};
+const isQueuedTicketStale = (metadata, isProcessActive) => {
+    return !isProcessActive(metadata.pid);
+};
+const waitForPollInterval = (ms, signal) => {
+    if (!signal) {
+        return wait(ms);
+    }
+    if (signal.aborted) {
+        return Promise.reject(signal.reason ?? createAbortError());
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', onAbort);
+            reject(signal.reason ?? createAbortError());
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+};
+const readQueueTickets = async (queueDir) => {
+    const ticketEntries = await fs.readdir(queueDir, { withFileTypes: true });
+    const tickets = await Promise.all(ticketEntries
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+        .map(async (entry) => ({
+        name: entry.name,
+        metadata: await readJsonFile(path.join(queueDir, entry.name)),
+    })));
+    return tickets
+        .filter((entry) => entry.metadata !== null)
+        .sort((left, right) => left.name.localeCompare(right.name))
+        .map((entry) => entry.metadata);
+};
+const cleanupQueue = async (options) => {
+    const { paths, currentTicketId, logger, isProcessActive } = options;
+    const tickets = await readQueueTickets(paths.queueDir);
+    const activeTickets = [];
+    for (const ticket of tickets) {
+        const isCurrentTicket = ticket.ticketId === currentTicketId;
+        const isStale = !isCurrentTicket && isQueuedTicketStale(ticket, isProcessActive);
+        if (isStale) {
+            logger.debug('removing stale queued ticket %s for key %s', ticket.ticketId, ticket.key);
+            await removeFileIfPresent(path.join(paths.queueDir, `${ticket.ticketId}.json`));
+            continue;
+        }
+        activeTickets.push(ticket);
+    }
+    return activeTickets;
+};
+const maybeClearStaleOwner = async (options) => {
+    const { ownerFilePath, staleLockTimeoutMs, now, logger, isProcessActive } = options;
+    const owner = await readJsonFile(ownerFilePath);
+    if (!owner) {
+        return null;
+    }
+    if (!isMetadataStale(owner, now, staleLockTimeoutMs, isProcessActive)) {
+        return owner;
+    }
+    logger.debug('removing stale owner ticket %s for key %s', owner.ticketId, owner.key);
+    await removeFileIfPresent(ownerFilePath);
+    return null;
+};
+const claimOwnership = async (ownerFilePath, metadata) => {
+    try {
+        await fs.writeFile(ownerFilePath, JSON.stringify(metadata), {
+            encoding: 'utf8',
+            flag: 'wx',
+        });
+        return true;
+    }
+    catch (error) {
+        if (isExclusiveCreateError(error)) {
+            return false;
+        }
+        throw error;
+    }
+};
+export const createResourceLockManager = (options = {}) => {
+    const rootDir = options.rootDir ?? DEFAULT_ROOT_DIR;
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+    const staleLockTimeoutMs = options.staleLockTimeoutMs ?? DEFAULT_STALE_LOCK_TIMEOUT_MS;
+    const pid = options.pid ?? process.pid;
+    const scopedLogger = options.logger ?? resourceLockLogger;
+    const isProcessActive = options.isProcessActive ?? isPidActive;
+    return {
+        acquire: async (key, acquireOptions = {}) => {
+            const paths = getPathsForKey(rootDir, key);
+            await ensureLockDirectories(paths);
+            const createdAt = Date.now();
+            const ticketId = createTicketId(createdAt, pid);
+            const ticketPath = path.join(paths.queueDir, `${ticketId}.json`);
+            const metadata = {
+                ticketId,
+                key,
+                pid,
+                createdAt,
+                heartbeatAt: createdAt,
+            };
+            await fs.writeFile(ticketPath, JSON.stringify(metadata), 'utf8');
+            scopedLogger.debug('queued ticket %s for key %s', ticketId, key);
+            let heartbeatTimer = null;
+            let released = false;
+            let didNotifyWait = false;
+            const waitStartedAt = Date.now();
+            const release = async () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                    heartbeatTimer = null;
+                }
+                const owner = await readJsonFile(paths.ownerFilePath);
+                if (owner?.ticketId === ticketId) {
+                    await removeFileIfPresent(paths.ownerFilePath);
+                }
+                await removeFileIfPresent(ticketPath);
+                scopedLogger.debug('released ticket %s for key %s', ticketId, key);
+            };
+            const startHeartbeat = () => {
+                heartbeatTimer = setInterval(async () => {
+                    const nextHeartbeatAt = Date.now();
+                    const owner = await readJsonFile(paths.ownerFilePath);
+                    if (released || owner?.ticketId !== ticketId) {
+                        return;
+                    }
+                    const nextMetadata = {
+                        ...owner,
+                        heartbeatAt: nextHeartbeatAt,
+                    };
+                    if (released) {
+                        return;
+                    }
+                    await fs.writeFile(paths.ownerFilePath, JSON.stringify(nextMetadata), 'utf8');
+                    scopedLogger.debug('refreshed heartbeat for ticket %s', ticketId);
+                }, heartbeatIntervalMs);
+                heartbeatTimer.unref?.();
+            };
+            try {
+                while (true) {
+                    acquireOptions.signal?.throwIfAborted();
+                    const now = Date.now();
+                    const activeTickets = await cleanupQueue({
+                        paths,
+                        currentTicketId: ticketId,
+                        logger: scopedLogger,
+                        isProcessActive,
+                    });
+                    const ownIndex = activeTickets.findIndex((entry) => entry.ticketId === ticketId);
+                    if (ownIndex === -1) {
+                        throw new Error(`Queued ticket ${ticketId} disappeared before acquisition.`);
+                    }
+                    const owner = await maybeClearStaleOwner({
+                        ownerFilePath: paths.ownerFilePath,
+                        staleLockTimeoutMs,
+                        now,
+                        logger: scopedLogger,
+                        isProcessActive,
+                    });
+                    if (ownIndex === 0 && owner === null) {
+                        const claimed = await claimOwnership(paths.ownerFilePath, {
+                            ...metadata,
+                            heartbeatAt: Date.now(),
+                        });
+                        if (claimed) {
+                            await removeFileIfPresent(ticketPath);
+                            startHeartbeat();
+                            scopedLogger.debug('acquired lock for key %s with ticket %s', key, ticketId);
+                            return { release };
+                        }
+                    }
+                    if (!didNotifyWait) {
+                        didNotifyWait = true;
+                        acquireOptions.onWait?.();
+                    }
+                    acquireOptions.onStillWaiting?.(Date.now() - waitStartedAt);
+                    scopedLogger.debug('waiting for key %s with ticket %s at queue position %d', key, ticketId, ownIndex + 1);
+                    await waitForPollInterval(pollIntervalMs, acquireOptions.signal);
+                }
+            }
+            catch (error) {
+                await release();
+                throw error;
+            }
+        },
+    };
+};

package/dist/run.d.ts

@@ -1,11 +1,17 @@
 import type { Config as JestConfig } from 'jest-runner';
 import { TestResult as JestTestResult } from '@jest/test-result';
+import type { TestSuiteResult as HarnessTestSuiteResult } from '@react-native-harness/bridge';
 import type { Harness } from './harness.js';
 export type RunHarnessTestFile = (options: {
     testPath: string;
     harness: Harness;
     projectConfig: JestConfig.ProjectConfig;
     globalConfig: JestConfig.GlobalConfig;
-}) => Promise<JestTestResult>;
+}) => Promise<{
+    jestResult: JestTestResult;
+    harnessResult: HarnessTestSuiteResult;
+    relativeTestPath: string;
+    duration: number;
+}>;
 export declare const runHarnessTestFile: RunHarnessTestFile;
 //# sourceMappingURL=run.d.ts.map

package/dist/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAKjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAuD5C,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,UAAU,CAAC,aAAa,CAAC;IACxC,YAAY,EAAE,UAAU,CAAC,YAAY,CAAC;CACvC,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;AAE9B,eAAO,MAAM,kBAAkB,EAAE,kBA6EhC,CAAC"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,IAAI,sBAAsB,EAE1C,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAuD5C,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,UAAU,CAAC,aAAa,CAAC;IACxC,YAAY,EAAE,UAAU,CAAC,YAAY,CAAC;CACvC,KAAK,OAAO,CAAC;IACZ,UAAU,EAAE,cAAc,CAAC;IAC3B,aAAa,EAAE,sBAAsB,CAAC;IACtC,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,kBAkFhC,CAAC"}