@react-native-harness/jest 1.4.0 → 1.5.0

package/dist/__tests__/hook-queue.test.js

@@ -1,56 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createHookQueue } from '../hook-queue.js';
-describe('createHookQueue', () => {
-    it('executes scheduled work in FIFO order', async () => {
-        const queue = createHookQueue();
-        const order = [];
-        queue.schedule(async () => { order.push(1); });
-        queue.schedule(async () => { order.push(2); });
-        queue.schedule(async () => { order.push(3); });
-        await queue.drain();
-        expect(order).toEqual([1, 2, 3]);
-    });
-    it('drain awaits async work before resolving', async () => {
-        const queue = createHookQueue();
-        let resolved = false;
-        queue.schedule(async () => {
-            await new Promise((r) => setTimeout(r, 20));
-            resolved = true;
-        });
-        expect(resolved).toBe(false);
-        await queue.drain();
-        expect(resolved).toBe(true);
-    });
-    it('drain resolves immediately when nothing is scheduled', async () => {
-        const queue = createHookQueue();
-        await expect(queue.drain()).resolves.toBeUndefined();
-    });
-    it('captures the first error and re-throws it on drain', async () => {
-        const queue = createHookQueue();
-        const err = new Error('hook failed');
-        queue.schedule(async () => { throw err; });
-        await expect(queue.drain()).rejects.toBe(err);
-    });
-    it('continues executing subsequent hooks after one throws', async () => {
-        const queue = createHookQueue();
-        const ran = [];
-        queue.schedule(async () => { throw new Error('first'); });
-        queue.schedule(async () => { ran.push('second'); });
-        queue.schedule(async () => { ran.push('third'); });
-        await expect(queue.drain()).rejects.toThrow('first');
-        expect(ran).toEqual(['second', 'third']);
-    });
-    it('error is cleared after drain re-throws it', async () => {
-        const queue = createHookQueue();
-        queue.schedule(async () => { throw new Error('once'); });
-        await expect(queue.drain()).rejects.toThrow('once');
-        // Second drain should see no accumulated error.
-        await expect(queue.drain()).resolves.toBeUndefined();
-    });
-    it('surfaces only the first error when multiple hooks throw', async () => {
-        const queue = createHookQueue();
-        queue.schedule(async () => { throw new Error('first'); });
-        queue.schedule(async () => { throw new Error('second'); });
-        await expect(queue.drain()).rejects.toThrow('first');
-    });
-});

package/dist/__tests__/index.test.d.ts

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

package/dist/__tests__/index.test.d.ts.map

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

package/dist/__tests__/index.test.js

@@ -1,150 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { createDiagnostics, HarnessError } from '@react-native-harness/tools';
-import JestHarness from '../index.js';
-const resolveUndefined = async () => undefined;
-// ---------------------------------------------------------------------------
-// Module mocks
-// ---------------------------------------------------------------------------
-const mockSession = {
-    config: { metroPort: 8081 },
-    context: {},
-    diagnostics: createDiagnostics({ enabled: false }),
-    onTestRunnerEvent: vi.fn(() => () => undefined),
-    ensureAppReady: vi.fn(resolveUndefined),
-    runTestFile: vi.fn(async () => ({
-        name: '',
-        tests: [],
-        suites: [],
-        status: 'passed',
-        duration: 0,
-    })),
-    restartApp: vi.fn(resolveUndefined),
-    resetEnvironment: vi.fn(resolveUndefined),
-    resetCrashState: vi.fn(),
-    flushClientLogs: vi.fn(() => []),
-    callHook: vi.fn(resolveUndefined),
-    setRunState: vi.fn(),
-    dispose: vi.fn(resolveUndefined),
-};
-const mockCreateHarnessSession = vi.hoisted(() => vi.fn(async () => mockSession));
-const mockExecuteRun = vi.hoisted(() => vi.fn(async () => undefined));
-vi.mock('../harness-session.js', () => ({
-    createHarnessSession: mockCreateHarnessSession,
-}));
-vi.mock('../execute-run.js', () => ({
-    executeRun: mockExecuteRun,
-}));
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-const makeOptions = () => ({ serial: true });
-const makeWatcher = () => ({ isInterrupted: () => false });
-const makeTest = () => ({
-    path: '/test/example.ts',
-    context: { config: {} },
-});
-const makeGlobalConfig = (overrides = {}) => ({ rootDir: '/project', watch: false, watchAll: false, collectCoverage: false, ...overrides });
-const typedMockExecuteRun = mockExecuteRun;
-const makeTestCaseStartPayload = () => [
-    '/test/example.ts',
-    {
-        ancestorTitles: [],
-        fullName: 'suite case',
-        mode: undefined,
-        title: 'case',
-        startedAt: 1,
-    },
-];
-const makeTestCaseResultPayload = () => [
-    '/test/example.ts',
-    {
-        ancestorTitles: [],
-        duration: 1,
-        failureDetails: [],
-        failureMessages: [],
-        fullName: 'suite case',
-        numPassingAsserts: 1,
-        startedAt: 1,
-        status: 'passed',
-        title: 'case',
-    },
-];
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-beforeEach(() => {
-    vi.clearAllMocks();
-    mockSession.dispose.mockResolvedValue(undefined);
-    typedMockExecuteRun.mockResolvedValue(undefined);
-    mockCreateHarnessSession.mockResolvedValue(mockSession);
-});
-describe('JestHarness', () => {
-    describe('session lifecycle', () => {
-        it('creates a session on the first run', async () => {
-            const runner = new JestHarness(makeGlobalConfig());
-            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-            expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
-        });
-        it('reuses the session across runs in watch mode', async () => {
-            const runner = new JestHarness(makeGlobalConfig({ watch: true }));
-            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-            expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
-            expect(mockSession.dispose).not.toHaveBeenCalled();
-        });
-        it('disposes the session after each run in normal mode', async () => {
-            const runner = new JestHarness(makeGlobalConfig());
-            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-            expect(mockSession.dispose).toHaveBeenCalledOnce();
-        });
-        it('creates a fresh session for each run in normal mode', async () => {
-            const runner = new JestHarness(makeGlobalConfig());
-            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-            expect(mockCreateHarnessSession).toHaveBeenCalledTimes(2);
-        });
-        it('emits registered Jest events', async () => {
-            const runner = new JestHarness(makeGlobalConfig());
-            const listener = vi.fn();
-            const eventPayload = makeTestCaseStartPayload();
-            runner.on('test-case-start', listener);
-            typedMockExecuteRun.mockImplementationOnce(async (_session, _tests, _watcher, emitEvent) => {
-                await emitEvent('test-case-start', ...eventPayload);
-            });
-            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-            expect(listener).toHaveBeenCalledWith(eventPayload);
-        });
-        it('stops emitting after listener unsubscribe', async () => {
-            const runner = new JestHarness(makeGlobalConfig());
-            const listener = vi.fn();
-            const unsubscribe = runner.on('test-case-result', listener);
-            const eventPayload = makeTestCaseResultPayload();
-            unsubscribe();
-            typedMockExecuteRun.mockImplementationOnce(async (_session, _tests, _watcher, emitEvent) => {
-                await emitEvent('test-case-result', ...eventPayload);
-            });
-            await runner.runTests([makeTest()], makeWatcher(), makeOptions());
-            expect(listener).not.toHaveBeenCalled();
-        });
-    });
-    describe('error handling', () => {
-        it('converts HarnessError into a formatted string before throwing', async () => {
-            class TestHarnessError extends HarnessError {
-                constructor() { super('something went wrong'); this.name = 'TestHarnessError'; }
-            }
-            mockCreateHarnessSession.mockRejectedValue(new TestHarnessError());
-            const runner = new JestHarness(makeGlobalConfig());
-            await expect(runner.runTests([makeTest()], makeWatcher(), makeOptions())).rejects.toBeTypeOf('string');
-        });
-        it('propagates non-HarnessError exceptions as-is', async () => {
-            const cause = new TypeError('unexpected');
-            mockCreateHarnessSession.mockRejectedValue(cause);
-            const runner = new JestHarness(makeGlobalConfig());
-            await expect(runner.runTests([makeTest()], makeWatcher(), makeOptions())).rejects.toBe(cause);
-        });
-        it('throws when called without serial flag', async () => {
-            const runner = new JestHarness(makeGlobalConfig());
-            await expect(runner.runTests([makeTest()], makeWatcher(), { serial: false })).rejects.toThrow('Parallel test running is not supported');
-        });
-    });
-});

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

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

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

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

@@ -1,54 +0,0 @@
-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,
-    diagnostics: false,
-    maxAppRestarts: 2,
-    metroPort: 8081,
-    platformReadyTimeout: 300_000,
-    resetEnvironmentBetweenTestFiles: true,
-    runners: [],
-    testTimeout: 5_000,
-    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

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

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

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

@@ -1,138 +0,0 @@
-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 } 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',
-        });
-        // 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({
-            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 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 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({
-            rootDir,
-            pollIntervalMs: 5,
-            heartbeatIntervalMs: 10,
-            staleLockTimeoutMs: 200,
-        });
-        const key = 'ios:simulator:iPhone 17 Pro:26.2';
-        const actualWriteFile = fs.writeFile.bind(fs);
-        const writeFileSpy = vi
-            .spyOn(fs, 'writeFile')
-            .mockImplementation(async (file, data, options) => {
-            // 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) {
-                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/__tests__/run.test.d.ts

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

package/dist/__tests__/run.test.d.ts.map

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

package/dist/__tests__/run.test.js

@@ -1,48 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { runHarnessTestFile } from '../run.js';
-vi.mock('jest-message-util', () => ({
-    formatResultsErrors: vi.fn(() => ''),
-}));
-const createHarnessResult = () => ({
-    name: 'root',
-    tests: [],
-    suites: [],
-    status: 'passed',
-    duration: 0,
-});
-const createSession = (testTimeout) => ({
-    config: { testTimeout },
-    context: {
-        platform: {
-            runner: './runner.js',
-        },
-    },
-    runTestFile: vi.fn(async () => createHarnessResult()),
-});
-const createGlobalConfig = (overrides = {}) => ({
-    rootDir: '/project',
-    ...overrides,
-});
-const createProjectConfig = (overrides = {}) => overrides;
-describe('runHarnessTestFile', () => {
-    it('uses Harness config testTimeout when Jest config does not set one', async () => {
-        const session = createSession(15000);
-        await runHarnessTestFile({
-            testPath: '/project/example.harness.ts',
-            session,
-            globalConfig: createGlobalConfig(),
-            projectConfig: createProjectConfig(),
-        });
-        expect(session.runTestFile).toHaveBeenCalledWith('example.harness.ts', expect.objectContaining({ testTimeout: 15000 }));
-    });
-    it('keeps Harness config testTimeout above Jest config testTimeout', async () => {
-        const session = createSession(15000);
-        await runHarnessTestFile({
-            testPath: '/project/example.harness.ts',
-            session,
-            globalConfig: createGlobalConfig({ testTimeout: 20000 }),
-            projectConfig: createProjectConfig({ testTimeout: 30000 }),
-        });
-        expect(session.runTestFile).toHaveBeenCalledWith('example.harness.ts', expect.objectContaining({ testTimeout: 15000 }));
-    });
-});

package/dist/__tests__/test-file-platform-filter.test.d.ts

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

package/dist/__tests__/test-file-platform-filter.test.d.ts.map

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

package/dist/__tests__/test-file-platform-filter.test.js

@@ -1,47 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createPlatformSkippedTestResult, getHarnessTestFilePlatform, shouldRunHarnessTestFile, } from '../test-file-platform-filter.js';
-const knownPlatformIds = new Set(['android', 'ios', 'web', 'vega']);
-describe('getHarnessTestFilePlatform', () => {
-    it('returns null for shared harness test files', () => {
-        expect(getHarnessTestFilePlatform('/tests/smoke.harness.ts', knownPlatformIds)).toBeNull();
-        expect(getHarnessTestFilePlatform('/tests/smoke.harness.tsx', knownPlatformIds)).toBeNull();
-        expect(getHarnessTestFilePlatform('/tests/smoke.harness.mjs', knownPlatformIds)).toBeNull();
-    });
-    it('returns the platform id for platform-specific harness test files', () => {
-        expect(getHarnessTestFilePlatform('/tests/kotlin.android.harness.ts', knownPlatformIds)).toBe('android');
-        expect(getHarnessTestFilePlatform('/tests/swift.ios.harness.ts', knownPlatformIds)).toBe('ios');
-        expect(getHarnessTestFilePlatform('/tests/browser.web.harness.ts', knownPlatformIds)).toBe('web');
-    });
-    it('returns null when the segment before .harness is not a known platform id', () => {
-        expect(getHarnessTestFilePlatform('/tests/smoke.harness.ts', knownPlatformIds)).toBeNull();
-        expect(getHarnessTestFilePlatform('/tests/custom.foo.harness.ts', knownPlatformIds)).toBeNull();
-    });
-});
-describe('shouldRunHarnessTestFile', () => {
-    it('runs shared harness test files on every platform', () => {
-        expect(shouldRunHarnessTestFile('/tests/smoke.harness.ts', 'android', knownPlatformIds)).toBe(true);
-        expect(shouldRunHarnessTestFile('/tests/smoke.harness.ts', 'ios', knownPlatformIds)).toBe(true);
-    });
-    it('runs platform-specific files only on the matching platform', () => {
-        expect(shouldRunHarnessTestFile('/tests/kotlin.android.harness.ts', 'android', knownPlatformIds)).toBe(true);
-        expect(shouldRunHarnessTestFile('/tests/kotlin.android.harness.ts', 'ios', knownPlatformIds)).toBe(false);
-        expect(shouldRunHarnessTestFile('/tests/swift.ios.harness.ts', 'ios', knownPlatformIds)).toBe(true);
-        expect(shouldRunHarnessTestFile('/tests/swift.ios.harness.ts', 'android', knownPlatformIds)).toBe(false);
-    });
-});
-describe('createPlatformSkippedTestResult', () => {
-    it('marks the entire test file as skipped', () => {
-        const result = createPlatformSkippedTestResult('/tests/swift.ios.harness.ts');
-        expect(result.skipped).toBe(true);
-        expect(result.numPassingTests).toBe(0);
-        expect(result.numFailingTests).toBe(0);
-        expect(result.numPendingTests).toBe(1);
-        expect(result.testResults).toHaveLength(1);
-        expect(result.testResults[0]).toEqual(expect.objectContaining({
-            status: 'skipped',
-            title: 'swift.ios.harness.ts',
-            fullName: 'swift.ios.harness.ts',
-        }));
-        expect(result.testFilePath).toBe('/tests/swift.ios.harness.ts');
-    });
-});

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

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

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

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

package/dist/cli-args.test.js

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

package/dist/crash-supervisor.d.ts

@@ -1,21 +0,0 @@
-import { type AppMonitor, type HarnessPlatformRunner } from '@react-native-harness/platforms';
-export type CrashSupervisorState = 'idle' | 'launching' | 'ready' | 'running' | 'disposing';
-export type CrashSupervisor = {
-    setActiveTestFile: (testFilePath: string | null) => void;
-    beginLaunch: (testFilePath: string) => void;
-    markReady: () => void;
-    beginTestRun: (testFilePath: string) => void;
-    stop: () => Promise<void>;
-    start: () => Promise<void>;
-    waitForCrash: (testFilePath: string) => Promise<never>;
-    isReady: () => boolean;
-    cancelCrashWaiters: () => void;
-    reset: () => void;
-    dispose: () => Promise<void>;
-};
-export type CrashSupervisorOptions = {
-    appMonitor: AppMonitor;
-    platformRunner: HarnessPlatformRunner;
-};
-export declare const createCrashSupervisor: ({ appMonitor, platformRunner, }: CrashSupervisorOptions) => CrashSupervisor;
-//# sourceMappingURL=crash-supervisor.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"crash-supervisor.d.ts","sourceRoot":"","sources":["../src/crash-supervisor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EAIf,KAAK,qBAAqB,EAC3B,MAAM,iCAAiC,CAAC;AAUzC,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,WAAW,GACX,OAAO,GACP,SAAS,GACT,WAAW,CAAC;AAEhB,MAAM,MAAM,eAAe,GAAG;IAC5B,iBAAiB,EAAE,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACzD,WAAW,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5C,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,YAAY,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,YAAY,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;IACvD,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,UAAU,EAAE,UAAU,CAAC;IACvB,cAAc,EAAE,qBAAqB,CAAC;CACvC,CAAC;AAmCF,eAAO,MAAM,qBAAqB,GAAI,iCAGnC,sBAAsB,KAAG,eAkP3B,CAAC"}