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

package/dist/__tests__/errors.test.js

@@ -1,5 +1,10 @@
 import { describe, expect, it } from 'vitest';
-import { NativeCrashError } from '../errors.js';
+import { NativeCrashError, PlatformReadyTimeoutError } from '../errors.js';
+describe('PlatformReadyTimeoutError', () => {
+    it('includes the configured timeout and config hint', () => {
+        expect(new PlatformReadyTimeoutError(300000).message).toBe('The platform did not become ready within 300000ms. Increase "platformReadyTimeout" if your device, simulator, or emulator needs more time to start.');
+    });
+});
 describe('NativeCrashError', () => {
     it('formats the extracted stack trace in the error message', () => {
         const error = new NativeCrashError('/tmp/crash.harness.ts', {

package/dist/__tests__/harness-cache.test.js

@@ -17,10 +17,10 @@ const platform = {
     platformId: 'ios',
     runner: '/virtual/platform-runner.js',
     config: {},
+    getResourceLockKey: () => 'ios:simulator:iPhone 17 Pro:26.2',
 };
 const createHarnessConfig = (overrides = {}) => ({
     appRegistryComponentName: 'App',
-    webSocketPort: 8081,
     disableViewFlattening: false,
     bridgeTimeout: 5000,
     entryPoint: 'index.js',

package/dist/__tests__/harness.test.js

@@ -1,5 +1,7 @@
 import { EventEmitter } from 'node:events';
+import { HARNESS_BRIDGE_PATH } from '@react-native-harness/bridge';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { MetroPortRangeExhaustedError } from '../errors.js';
 import { definePlugin } from '@react-native-harness/plugins';
 import { createCrashSupervisor } from '../crash-supervisor.js';
 const mocks = vi.hoisted(() => ({
@@ -8,13 +10,19 @@ const mocks = vi.hoisted(() => ({
     getMetroInstance: vi.fn(),
     isMetroCacheReusable: vi.fn(() => false),
     logMetroCacheReused: vi.fn(),
+    logMetroPortFallback: vi.fn(),
+    logRunnerStarting: vi.fn(),
+    logRunnerStillWaitingInQueue: vi.fn(),
+    logRunnerWaitingInQueue: vi.fn(),
     waitForMetroBackedAppReady: vi.fn(),
+    isPortAvailable: vi.fn(async () => true),
 }));
 vi.mock('@react-native-harness/bundler-metro', async () => {
     const actual = await vi.importActual('@react-native-harness/bundler-metro');
     return {
         ...actual,
         getMetroInstance: mocks.getMetroInstance,
+        isPortAvailable: mocks.isPortAvailable,
         isMetroCacheReusable: mocks.isMetroCacheReusable,
         waitForMetroBackedAppReady: mocks.waitForMetroBackedAppReady,
     };
@@ -24,6 +32,10 @@ vi.mock('@react-native-harness/bridge/server', () => ({
 }));
 vi.mock('../logs.js', () => ({
     logMetroCacheReused: mocks.logMetroCacheReused,
+    logMetroPortFallback: mocks.logMetroPortFallback,
+    logRunnerStarting: mocks.logRunnerStarting,
+    logRunnerStillWaitingInQueue: mocks.logRunnerStillWaitingInQueue,
+    logRunnerWaitingInQueue: mocks.logRunnerWaitingInQueue,
 }));
 vi.mock('@react-native-harness/tools', async () => {
     const actual = await vi.importActual('@react-native-harness/tools');
@@ -33,11 +45,12 @@ vi.mock('@react-native-harness/tools', async () => {
     };
 });
 import { getHarness, waitForAppReady } from '../harness.js';
-import { StartupStallError } from '../errors.js';
+import { PlatformReadyTimeoutError, StartupStallError } from '../errors.js';
 const createBridgeServer = () => {
     const emitter = new EventEmitter();
     return {
         serverBridge: {
+            ws: {},
             rpc: {
                 clients: [],
             },
@@ -81,6 +94,8 @@ const createReporter = () => {
 };
 const createMetroInstance = (overrides = {}) => ({
     events: createReporter(),
+    httpServer: {},
+    websocketEndpoints: {},
     waitUntilHealthy: vi.fn(async () => 'HTTP 200: packager-status:running'),
     prewarm: vi.fn(async () => false),
     dispose: vi.fn(async () => undefined),
@@ -128,6 +143,7 @@ const createHarnessConfig = (overrides = {}) => ({
     forwardClientLogs: false,
     maxAppRestarts: 2,
     metroPort: 8081,
+    platformReadyTimeout: 300_000,
     resetEnvironmentBetweenTestFiles: true,
     runners: [],
     unstable__enableMetroCache: false,
@@ -137,6 +153,8 @@ const createHarnessConfig = (overrides = {}) => ({
 });
 beforeEach(() => {
     vi.clearAllMocks();
+    mocks.isPortAvailable.mockReset();
+    mocks.isPortAvailable.mockResolvedValue(true);
 });
 afterEach(() => {
     delete globalThis.__HARNESS_PLATFORM_RUNNER__;
@@ -220,6 +238,121 @@ describe('waitForAppReady', () => {
     });
 });
 describe('getHarness', () => {
+    it('fails when the platform runner does not become ready within platformReadyTimeout', async () => {
+        const { serverBridge } = createBridgeServer();
+        const metroInstance = createMetroInstance();
+        mocks.getBridgeServer.mockResolvedValue(serverBridge);
+        mocks.getMetroInstance.mockResolvedValue(metroInstance);
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = vi.fn(async () => await new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new DOMException('The operation was aborted', 'AbortError'));
+            }, 20);
+        }));
+        const platform = {
+            config: {},
+            getResourceLockKey: () => 'ios:test-platform-ready-timeout',
+            name: 'ios',
+            platformId: 'ios',
+            runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+        };
+        await expect(getHarness(createHarnessConfig({
+            platformReadyTimeout: 10,
+        }), platform, '/tmp/project')).rejects.toBeInstanceOf(PlatformReadyTimeoutError);
+    });
+    it('passes a platform init signal to the runner factory', async () => {
+        const { serverBridge } = createBridgeServer();
+        const appMonitor = createAppMonitor();
+        const platformInstance = createPlatformRunner({
+            createAppMonitor: () => appMonitor.appMonitor,
+        });
+        const metroInstance = createMetroInstance();
+        mocks.getBridgeServer.mockResolvedValue(serverBridge);
+        mocks.getMetroInstance.mockResolvedValue(metroInstance);
+        const runner = vi.fn(async () => platformInstance);
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = runner;
+        const platform = {
+            config: {},
+            getResourceLockKey: () => 'ios:test-platform-init-signal',
+            name: 'ios',
+            platformId: 'ios',
+            runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+        };
+        const harness = await getHarness(createHarnessConfig(), platform, '/tmp/project');
+        expect(runner).toHaveBeenCalledWith(platform.config, expect.objectContaining({
+            metroPort: 8081,
+        }), expect.objectContaining({
+            signal: expect.any(AbortSignal),
+        }));
+        await harness.dispose();
+    });
+    it('resolves and exposes a fallback Metro port before platform init', async () => {
+        const { serverBridge } = createBridgeServer();
+        const appMonitor = createAppMonitor();
+        const platformInstance = createPlatformRunner({
+            createAppMonitor: () => appMonitor.appMonitor,
+        });
+        const metroInstance = createMetroInstance();
+        mocks.getBridgeServer.mockResolvedValue(serverBridge);
+        mocks.getMetroInstance.mockResolvedValue(metroInstance);
+        mocks.isPortAvailable
+            .mockResolvedValueOnce(false)
+            .mockResolvedValueOnce(true);
+        const runner = vi.fn(async () => platformInstance);
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = runner;
+        const platform = {
+            config: {},
+            getResourceLockKey: () => 'android:emulator:Pixel_8_API_35',
+            name: 'android',
+            platformId: 'android',
+            runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+        };
+        const harness = await getHarness(createHarnessConfig(), platform, '/tmp/project');
+        expect(harness.config.metroPort).toBe(8082);
+        expect(mocks.getMetroInstance).toHaveBeenCalledWith(expect.objectContaining({
+            harnessConfig: expect.objectContaining({
+                metroPort: 8082,
+            }),
+        }), expect.any(AbortSignal));
+        expect(runner).toHaveBeenCalledWith(platform.config, expect.objectContaining({
+            metroPort: 8082,
+        }), expect.objectContaining({
+            signal: expect.any(AbortSignal),
+        }));
+        expect(mocks.logMetroPortFallback).toHaveBeenCalledWith(8081, 8082);
+        await harness.dispose();
+    });
+    it('fails when no Metro port is available in the retry window', async () => {
+        mocks.isPortAvailable.mockResolvedValue(false);
+        const platform = {
+            config: {},
+            getResourceLockKey: () => 'android:emulator:Pixel_8_API_35',
+            name: 'android',
+            platformId: 'android',
+            runner: 'data:text/javascript,export default async () => ({})',
+        };
+        await expect(getHarness(createHarnessConfig(), platform, '/tmp/project')).rejects.toBeInstanceOf(MetroPortRangeExhaustedError);
+        expect(mocks.getBridgeServer).not.toHaveBeenCalled();
+        expect(mocks.getMetroInstance).not.toHaveBeenCalled();
+    });
+    it('falls back to a default resource lock key for platforms without getResourceLockKey', async () => {
+        const { serverBridge } = createBridgeServer();
+        const appMonitor = createAppMonitor();
+        const platformInstance = createPlatformRunner({
+            createAppMonitor: () => appMonitor.appMonitor,
+        });
+        const metroInstance = createMetroInstance();
+        mocks.getBridgeServer.mockResolvedValue(serverBridge);
+        mocks.getMetroInstance.mockResolvedValue(metroInstance);
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = vi.fn(async () => platformInstance);
+        const platform = {
+            config: {},
+            name: 'legacy-ios',
+            platformId: 'ios',
+            runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+        };
+        const harness = await getHarness(createHarnessConfig(), platform, '/tmp/project');
+        await harness.dispose();
+    });
     it('routes ensureAppReady through the shared Metro startup helper', async () => {
         const { serverBridge, emitReady } = createBridgeServer();
         const appMonitor = createAppMonitor();
@@ -249,8 +382,11 @@ describe('getHarness', () => {
             name: 'ios',
             platformId: 'ios',
             runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+            getResourceLockKey: () => 'ios:simulator:iPhone 17 Pro:26.2',
         };
-        const harness = await getHarness(createHarnessConfig(), platform, '/tmp/project');
+        const harness = await getHarness(createHarnessConfig({
+            bridgeTimeout: 1,
+        }), platform, '/tmp/project');
         await harness.ensureAppReady('/tmp/example.harness.ts');
         expect(mocks.waitForMetroBackedAppReady).toHaveBeenCalledTimes(1);
         expect(restartApp).toHaveBeenCalledWith({
@@ -292,8 +428,17 @@ describe('getHarness', () => {
             name: 'ios',
             platformId: 'ios',
             runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+            getResourceLockKey: () => 'ios:simulator:iPhone 17 Pro:26.2',
         };
         const harness = await getHarness(createHarnessConfig(), platform, '/tmp/project');
+        expect(mocks.getBridgeServer).toHaveBeenCalledWith(expect.objectContaining({
+            noServer: true,
+        }));
+        expect(mocks.getMetroInstance).toHaveBeenCalledWith(expect.objectContaining({
+            websocketEndpoints: {
+                [HARNESS_BRIDGE_PATH]: serverBridge.ws,
+            },
+        }), expect.any(AbortSignal));
         await harness.restart('/tmp/restart.harness.ts');
         expect(stopApp).toHaveBeenCalledTimes(1);
         expect(mocks.waitForMetroBackedAppReady).toHaveBeenCalledTimes(1);
@@ -326,7 +471,17 @@ describe('plugins', () => {
                 harness: {
                     beforeCreation: (ctx) => {
                         ctx.state.creationCount += 1;
-                        observedHooks.push(`beforeCreation:${ctx.platform.platformId}:${ctx.appLaunchOptions == null ? 'no-launch-options' : 'launch-options'}`);
+                        observedHooks.push(`beforeCreation:${ctx.platform.platformId}:${ctx.appLaunchOptions == null
+                            ? 'no-launch-options'
+                            : 'launch-options'}`);
+                    },
+                    beforeRun: (ctx) => {
+                        observedHooks.push(`beforeRun:${ctx.platform.platformId}:${ctx.appLaunchOptions == null
+                            ? 'no-launch-options'
+                            : 'launch-options'}`);
+                    },
+                    afterRun: (ctx) => {
+                        observedHooks.push(`afterRun:${ctx.state.creationCount}:${ctx.reason}`);
                     },
                     beforeDispose: (ctx) => {
                         observedHooks.push(`beforeDispose:${ctx.state.creationCount}:${ctx.reason}`);
@@ -358,6 +513,7 @@ describe('plugins', () => {
             name: 'ios',
             platformId: 'ios',
             runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+            getResourceLockKey: () => 'ios:simulator:iPhone 17 Pro:26.2',
         };
         const harness = await getHarness(createHarnessConfig({
             plugins: [plugin],
@@ -385,12 +541,58 @@ describe('plugins', () => {
         await harness.dispose();
         expect(observedHooks).toEqual([
             'beforeCreation:ios:launch-options',
+            'beforeRun:ios:launch-options',
             'runtime.ready:run-1:ios',
             'collection.started:example.harness.ts',
             'runtime.disconnected:bridge-disconnected',
+            'afterRun:1:normal',
             'beforeDispose:1:normal',
         ]);
     });
+    it('waits in queue before starting Metro and releases the lock on dispose', async () => {
+        const resourceKey = 'ios:simulator:iPhone 17 Pro:26.2';
+        const firstPlatformRunner = createPlatformRunner();
+        const secondPlatformRunner = createPlatformRunner();
+        const secondAppMonitor = createAppMonitor();
+        const firstMetroInstance = createMetroInstance();
+        const secondMetroInstance = createMetroInstance();
+        const firstBridge = createBridgeServer();
+        const secondBridge = createBridgeServer();
+        mocks.getBridgeServer
+            .mockResolvedValueOnce(firstBridge.serverBridge)
+            .mockResolvedValueOnce(secondBridge.serverBridge);
+        mocks.getMetroInstance
+            .mockResolvedValueOnce(firstMetroInstance)
+            .mockResolvedValueOnce(secondMetroInstance);
+        let invocationCount = 0;
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = vi.fn(async () => {
+            invocationCount += 1;
+            return invocationCount === 1
+                ? firstPlatformRunner
+                : createPlatformRunner({
+                    createAppMonitor: () => secondAppMonitor.appMonitor,
+                    dispose: secondPlatformRunner.dispose,
+                });
+        });
+        const platform = {
+            config: {},
+            name: 'ios',
+            platformId: 'ios',
+            runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+            getResourceLockKey: () => resourceKey,
+        };
+        const firstHarness = await getHarness(createHarnessConfig(), platform, '/tmp/project');
+        const secondHarnessPromise = getHarness(createHarnessConfig(), platform, '/tmp/project');
+        await new Promise((resolve) => setTimeout(resolve, 1100));
+        expect(mocks.logRunnerWaitingInQueue).toHaveBeenCalledWith(platform);
+        expect(mocks.logRunnerStarting).not.toHaveBeenCalled();
+        expect(mocks.getMetroInstance).toHaveBeenCalledTimes(1);
+        await firstHarness.dispose();
+        const secondHarness = await secondHarnessPromise;
+        expect(mocks.logRunnerStarting).toHaveBeenCalledWith(platform);
+        expect(mocks.getMetroInstance).toHaveBeenCalledTimes(2);
+        await secondHarness.dispose();
+    });
 });
 describe('StartupStallError', () => {
     it('includes the configured timeout and attempt count', () => {

package/dist/__tests__/metro-port.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=metro-port.test.d.ts.map

package/dist/__tests__/metro-port.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metro-port.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/metro-port.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/metro-port.test.js

@@ -0,0 +1,52 @@
+import { describe, expect, it, vi } from 'vitest';
+import { resolveHarnessMetroPort } from '../metro-port.js';
+const mocks = vi.hoisted(() => ({
+    isPortAvailable: vi.fn(async () => true),
+}));
+vi.mock('@react-native-harness/bundler-metro', () => ({
+    isPortAvailable: mocks.isPortAvailable,
+}));
+const createConfig = (overrides = {}) => ({
+    appRegistryComponentName: 'App',
+    bridgeTimeout: 60_000,
+    bundleStartTimeout: 60_000,
+    crashDetectionInterval: 500,
+    defaultRunner: 'ios-device',
+    detectNativeCrashes: true,
+    disableViewFlattening: false,
+    entryPoint: 'index.js',
+    forwardClientLogs: false,
+    maxAppRestarts: 2,
+    metroPort: 8081,
+    platformReadyTimeout: 300_000,
+    resetEnvironmentBetweenTestFiles: true,
+    runners: [],
+    unstable__enableMetroCache: false,
+    unstable__skipAlreadyIncludedModules: false,
+    ...overrides,
+});
+describe('resolveHarnessMetroPort', () => {
+    it('skips fallback allocation for iOS physical device runners', async () => {
+        const acquire = vi.fn();
+        const config = createConfig();
+        const platform = {
+            config: {},
+            name: 'ios-device',
+            platformId: 'ios',
+            runner: 'unused',
+        };
+        const result = await resolveHarnessMetroPort({
+            config,
+            platform,
+            resourceLockManager: {
+                acquire,
+            },
+            signal: new AbortController().signal,
+        });
+        expect(result.config).toBe(config);
+        expect(result.metroPortLease).toBeNull();
+        expect(result.didFallback).toBe(false);
+        expect(acquire).not.toHaveBeenCalled();
+        expect(mocks.isPortAvailable).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/resource-lock.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resource-lock.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resource-lock.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/resource-lock.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,138 @@
+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';
+describe('resource lock manager', () => {
+    let rootDir;
+    beforeEach(async () => {
+        rootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'react-native-harness-resource-lock-test-'));
+    });
+    afterEach(async () => {
+        await fs.rm(rootDir, { recursive: true, force: true });
+    });
+    it('queues access in FIFO order', async () => {
+        const manager = createResourceLockManager({
+            rootDir,
+            pollIntervalMs: 5,
+            heartbeatIntervalMs: 20,
+            staleLockTimeoutMs: 200,
+        });
+        const order = [];
+        const firstLease = await manager.acquire('ios:simulator:iPhone 17 Pro:26.2');
+        const secondAcquire = manager
+            .acquire('ios:simulator:iPhone 17 Pro:26.2', {
+            onWait: () => {
+                order.push('waiting');
+            },
+        })
+            .then(async (lease) => {
+            order.push('acquired');
+            await lease.release();
+        });
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        expect(order).toEqual(['waiting']);
+        await firstLease.release();
+        await secondAcquire;
+        expect(order).toEqual(['waiting', 'acquired']);
+    });
+    it('removes the queued ticket when waiting is aborted', async () => {
+        const manager = createResourceLockManager({
+            rootDir,
+            pollIntervalMs: 5,
+            heartbeatIntervalMs: 20,
+            staleLockTimeoutMs: 200,
+        });
+        const key = 'android:emulator:Pixel_8_API_35';
+        const firstLease = await manager.acquire(key);
+        const controller = new AbortController();
+        const acquirePromise = manager.acquire(key, {
+            signal: controller.signal,
+        });
+        await new Promise((resolve) => setTimeout(resolve, 30));
+        controller.abort();
+        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);
+        await firstLease.release();
+    });
+    it('keeps queued tickets alive while the waiting process is still active', async () => {
+        const manager = createResourceLockManager({
+            rootDir,
+            pollIntervalMs: 5,
+            heartbeatIntervalMs: 20,
+            staleLockTimeoutMs: 30,
+            isProcessActive: () => true,
+        });
+        const key = 'ios:simulator:iPhone 17 Pro:26.2';
+        const firstLease = await manager.acquire(key);
+        const secondAcquire = manager.acquire(key);
+        await new Promise((resolve) => setTimeout(resolve, 80));
+        await firstLease.release();
+        const secondLease = await secondAcquire;
+        await secondLease.release();
+    });
+    it('reclaims a stale owner before granting the lock', async () => {
+        const manager = 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');
+        await lease.release();
+    });
+    it('keeps owner metadata valid when heartbeat writes overlap', async () => {
+        const manager = createResourceLockManager({
+            rootDir,
+            pollIntervalMs: 5,
+            heartbeatIntervalMs: 10,
+            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) {
+                await new Promise((resolve) => setTimeout(resolve, 25));
+            }
+            return await actualWriteFile(file, data, options);
+        });
+        try {
+            const lease = await manager.acquire(key);
+            const initialOwner = JSON.parse(await fs.readFile(ownerFilePath, 'utf8'));
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            for (let index = 0; index < 5; index += 1) {
+                const owner = JSON.parse(await fs.readFile(ownerFilePath, 'utf8'));
+                expect(owner.ticketId).toBe(initialOwner.ticketId);
+                await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+            await lease.release();
+        }
+        finally {
+            writeFileSpy.mockRestore();
+        }
+    });
+});

package/dist/action-hooks.d.ts

@@ -0,0 +1,9 @@
+import { type HarnessPlugin } from '@react-native-harness/plugins';
+import type { Config as HarnessConfig } from '@react-native-harness/config';
+import type { HarnessPlatform } from '@react-native-harness/platforms';
+type ActionHookState = {
+    _unused?: never;
+};
+export declare const createActionHooksPlugin: () => HarnessPlugin<ActionHookState, HarnessConfig, HarnessPlatform>;
+export {};
+//# sourceMappingURL=action-hooks.d.ts.map

package/dist/action-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-hooks.d.ts","sourceRoot":"","sources":["../src/action-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAGvE,KAAK,eAAe,GAAG;IACrB,OAAO,CAAC,EAAE,KAAK,CAAC;CACjB,CAAC;AAuBF,eAAO,MAAM,uBAAuB,QAAO,aAAa,CACtD,eAAe,EACf,aAAa,EACb,eAAe,CA6Bb,CAAC"}

package/dist/action-hooks.js

@@ -0,0 +1,36 @@
+import { definePlugin, } from '@react-native-harness/plugins';
+import { spawn } from '@react-native-harness/tools';
+const getInlineHookScript = (name) => {
+    const value = process.env[name]?.trim();
+    return value ? value : null;
+};
+const runInlineHook = async (script) => {
+    const env = Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] != null));
+    await spawn('bash', ['-lc', script], {
+        env,
+        cwd: process.env.HARNESS_PROJECT_ROOT,
+    });
+};
+export const createActionHooksPlugin = () => definePlugin({
+    name: 'github-action-hooks',
+    createState: () => ({}),
+    hooks: {
+        harness: {
+            beforeRun: async () => {
+                const script = getInlineHookScript('PRE_RUN_HOOK');
+                if (!script) {
+                    return;
+                }
+                await runInlineHook(script);
+            },
+            afterRun: async (ctx) => {
+                const script = getInlineHookScript('AFTER_RUN_HOOK');
+                if (!script) {
+                    return;
+                }
+                process.env.HARNESS_EXIT_CODE = ctx.status === 'passed' ? '0' : '1';
+                await runInlineHook(script);
+            },
+        },
+    },
+});

package/dist/cli-args.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli-args.test.d.ts.map

package/dist/cli-args.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-args.test.d.ts","sourceRoot":"","sources":["../src/cli-args.test.ts"],"names":[],"mappings":""}

package/dist/cli-args.test.js

@@ -0,0 +1 @@
+export {};

package/dist/crash-monitor.d.ts

@@ -0,0 +1,16 @@
+import { HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { BridgeServer } from '@react-native-harness/bridge/server';
+export type CrashMonitor = {
+    startMonitoring(testFilePath: string): Promise<never>;
+    stopMonitoring(): void;
+    markIntentionalRestart(): void;
+    clearIntentionalRestart(): void;
+    dispose(): void;
+};
+export type CrashMonitorOptions = {
+    interval: number;
+    platformRunner: HarnessPlatformRunner;
+    bridgeServer: BridgeServer;
+};
+export declare const createCrashMonitor: ({ interval, platformRunner, bridgeServer, }: CrashMonitorOptions) => CrashMonitor;
+//# sourceMappingURL=crash-monitor.d.ts.map

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

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