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

package/dist/__tests__/harness-cache.test.d.ts

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

package/dist/__tests__/harness-cache.test.d.ts.map

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

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

@@ -0,0 +1,51 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(() => ({
+    isMetroCacheReusable: vi.fn(),
+    logMetroCacheReused: vi.fn(),
+    logMetroPrewarmCompleted: vi.fn(),
+}));
+vi.mock('@react-native-harness/bundler-metro', () => ({
+    isMetroCacheReusable: mocks.isMetroCacheReusable,
+}));
+vi.mock('../logs.js', () => ({
+    logMetroCacheReused: mocks.logMetroCacheReused,
+    logMetroPrewarmCompleted: mocks.logMetroPrewarmCompleted,
+}));
+import { maybeLogMetroCacheReuse } from '../harness.js';
+const platform = {
+    name: 'ios',
+    platformId: 'ios',
+    runner: '/virtual/platform-runner.js',
+    config: {},
+};
+const createHarnessConfig = (overrides = {}) => ({
+    appRegistryComponentName: 'App',
+    webSocketPort: 8081,
+    disableViewFlattening: false,
+    bridgeTimeout: 5000,
+    entryPoint: 'index.js',
+    unstable__enableMetroCache: true,
+    forwardClientLogs: false,
+    ...overrides,
+});
+describe('maybeLogMetroCacheReuse', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mocks.isMetroCacheReusable.mockReturnValue(false);
+    });
+    it('logs when an existing metro cache will be reused', () => {
+        mocks.isMetroCacheReusable.mockReturnValue(true);
+        maybeLogMetroCacheReuse(createHarnessConfig(), platform, '/tmp/project');
+        expect(mocks.isMetroCacheReusable).toHaveBeenCalledWith('/tmp/project');
+        expect(mocks.logMetroCacheReused).toHaveBeenCalledWith(platform);
+    });
+    it('does not log when metro cache reuse is disabled', () => {
+        maybeLogMetroCacheReuse(createHarnessConfig({ unstable__enableMetroCache: false }), platform, '/tmp/project');
+        expect(mocks.isMetroCacheReusable).not.toHaveBeenCalled();
+        expect(mocks.logMetroCacheReused).not.toHaveBeenCalled();
+    });
+    it('does not log when the metro cache is absent', () => {
+        maybeLogMetroCacheReuse(createHarnessConfig(), platform, '/tmp/project');
+        expect(mocks.logMetroCacheReused).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/harness.test.js

@@ -1,86 +1,208 @@
 import { EventEmitter } from 'node:events';
-import { describe, expect, it, vi } from 'vitest';
-import { waitForAppReady } from '../harness.js';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { definePlugin } from '@react-native-harness/plugins';
 import { createCrashSupervisor } from '../crash-supervisor.js';
+const mocks = vi.hoisted(() => ({
+    createCrashArtifactWriter: vi.fn(() => ({})),
+    getBridgeServer: vi.fn(),
+    getMetroInstance: vi.fn(),
+    isMetroCacheReusable: vi.fn(() => false),
+    logMetroCacheReused: vi.fn(),
+    waitForMetroBackedAppReady: vi.fn(),
+}));
+vi.mock('@react-native-harness/bundler-metro', async () => {
+    const actual = await vi.importActual('@react-native-harness/bundler-metro');
+    return {
+        ...actual,
+        getMetroInstance: mocks.getMetroInstance,
+        isMetroCacheReusable: mocks.isMetroCacheReusable,
+        waitForMetroBackedAppReady: mocks.waitForMetroBackedAppReady,
+    };
+});
+vi.mock('@react-native-harness/bridge/server', () => ({
+    getBridgeServer: mocks.getBridgeServer,
+}));
+vi.mock('../logs.js', () => ({
+    logMetroCacheReused: mocks.logMetroCacheReused,
+}));
+vi.mock('@react-native-harness/tools', async () => {
+    const actual = await vi.importActual('@react-native-harness/tools');
+    return {
+        ...actual,
+        createCrashArtifactWriter: mocks.createCrashArtifactWriter,
+    };
+});
+import { getHarness, waitForAppReady } from '../harness.js';
+import { StartupStallError } from '../errors.js';
 const createBridgeServer = () => {
     const emitter = new EventEmitter();
     return {
         serverBridge: {
+            rpc: {
+                clients: [],
+            },
             on: emitter.on.bind(emitter),
             once: emitter.once.bind(emitter),
             off: emitter.off.bind(emitter),
+            dispose: vi.fn(),
         },
         emitReady: () => {
-            emitter.emit('ready');
+            emitter.emit('ready', {
+                platform: 'ios',
+                manufacturer: 'Apple',
+                model: 'Simulator',
+                osVersion: '18.0',
+            });
+        },
+        emitEvent: (event) => {
+            emitter.emit('event', event);
+        },
+        emitDisconnect: () => {
+            emitter.emit('disconnect');
         },
     };
 };
-const createAppMonitor = () => {
+const createReporter = () => {
     const listeners = new Set();
     return {
-        start: async () => undefined,
-        stop: async () => undefined,
-        dispose: async () => undefined,
         addListener: (listener) => {
             listeners.add(listener);
         },
         removeListener: (listener) => {
             listeners.delete(listener);
         },
+        emit: (event) => {
+            listeners.forEach((listener) => listener(event));
+        },
+        clearAllListeners: () => {
+            listeners.clear();
+        },
+    };
+};
+const createMetroInstance = (overrides = {}) => ({
+    events: createReporter(),
+    waitUntilHealthy: vi.fn(async () => 'HTTP 200: packager-status:running'),
+    prewarm: vi.fn(async () => false),
+    dispose: vi.fn(async () => undefined),
+    ...overrides,
+});
+const createAppMonitor = () => {
+    const listeners = new Set();
+    return {
+        appMonitor: {
+            start: vi.fn(async () => undefined),
+            stop: vi.fn(async () => undefined),
+            dispose: vi.fn(async () => undefined),
+            addListener: (listener) => {
+                listeners.add(listener);
+            },
+            removeListener: (listener) => {
+                listeners.delete(listener);
+            },
+        },
+        emit: (event) => {
+            for (const listener of listeners) {
+                listener(event);
+            }
+        },
     };
 };
-const createPlatformRunner = (restartApp) => ({
-    startApp: async () => undefined,
-    restartApp,
-    stopApp: async () => undefined,
-    dispose: async () => undefined,
-    isAppRunning: async () => true,
-    createAppMonitor: createAppMonitor,
+const createPlatformRunner = (overrides = {}) => ({
+    startApp: vi.fn(async () => undefined),
+    restartApp: vi.fn(async () => undefined),
+    stopApp: vi.fn(async () => undefined),
+    dispose: vi.fn(async () => undefined),
+    isAppRunning: vi.fn(async () => true),
+    createAppMonitor: () => createAppMonitor().appMonitor,
+    ...overrides,
+});
+const createHarnessConfig = (overrides = {}) => ({
+    appRegistryComponentName: 'App',
+    bridgeTimeout: 60_000,
+    bundleStartTimeout: 60_000,
+    crashDetectionInterval: 500,
+    defaultRunner: 'ios',
+    detectNativeCrashes: true,
+    disableViewFlattening: false,
+    entryPoint: 'index.js',
+    forwardClientLogs: false,
+    maxAppRestarts: 2,
+    metroPort: 8081,
+    resetEnvironmentBetweenTestFiles: true,
+    runners: [],
+    unstable__enableMetroCache: false,
+    unstable__skipAlreadyIncludedModules: false,
+    webSocketPort: 3001,
+    ...overrides,
+});
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+afterEach(() => {
+    delete globalThis.__HARNESS_PLATFORM_RUNNER__;
 });
 describe('waitForAppReady', () => {
-    it('passes launch options to the initial launch', async () => {
+    it('delegates startup orchestration to bundler-metro and resolves readiness from the bridge', async () => {
         const { serverBridge, emitReady } = createBridgeServer();
-        const restartApp = vi.fn().mockResolvedValue(undefined);
-        const platformInstance = createPlatformRunner(restartApp);
+        const metroInstance = createMetroInstance();
+        const platformInstance = createPlatformRunner();
+        const { appMonitor } = createAppMonitor();
         const crashSupervisor = createCrashSupervisor({
-            appMonitor: createAppMonitor(),
+            appMonitor,
             platformRunner: platformInstance,
         });
-        const promise = waitForAppReady({
+        mocks.waitForMetroBackedAppReady.mockImplementationOnce(async (options) => {
+            options.onAttemptStart?.();
+            const readyPromise = options.waitForReady(new AbortController().signal);
+            emitReady();
+            await readyPromise;
+            options.onAttemptReset?.();
+        });
+        await waitForAppReady({
+            metroInstance,
             serverBridge,
             platformInstance,
-            bridgeTimeout: 5000,
+            platformId: 'ios',
+            bundleStartTimeout: 1_500,
+            readyTimeout: 2_500,
+            maxAppRestarts: 3,
             testFilePath: '/tmp/test.harness.ts',
             crashSupervisor,
-            appLaunchOptions: {
-                extras: {
-                    mode: 'startup',
-                },
-            },
         });
-        await Promise.resolve();
-        expect(restartApp).toHaveBeenCalledWith({
-            extras: {
-                mode: 'startup',
-            },
-        });
-        emitReady();
-        await promise;
+        expect(mocks.waitForMetroBackedAppReady).toHaveBeenCalledWith(expect.objectContaining({
+            metro: metroInstance,
+            platformId: 'ios',
+            bundleStartTimeout: 1_500,
+            readyTimeout: 2_500,
+            maxAppRestarts: 3,
+            startAttempt: expect.any(Function),
+            waitForReady: expect.any(Function),
+            waitForCrash: expect.any(Function),
+        }));
+        expect(crashSupervisor.isReady()).toBe(true);
         await crashSupervisor.dispose();
     });
-    it('does not retry launch when the app never becomes ready', async () => {
-        vi.useFakeTimers();
+    it('passes launch options through the shared Metro startup helper', async () => {
         const { serverBridge } = createBridgeServer();
-        const restartApp = vi.fn().mockResolvedValue(undefined);
-        const platformInstance = createPlatformRunner(restartApp);
+        const metroInstance = createMetroInstance();
+        const restartApp = vi.fn(async () => undefined);
+        const platformInstance = createPlatformRunner({ restartApp });
+        const { appMonitor } = createAppMonitor();
         const crashSupervisor = createCrashSupervisor({
-            appMonitor: createAppMonitor(),
+            appMonitor,
             platformRunner: platformInstance,
         });
-        const promise = waitForAppReady({
+        mocks.waitForMetroBackedAppReady.mockImplementationOnce(async (options) => {
+            await options.startAttempt();
+        });
+        await waitForAppReady({
+            metroInstance,
             serverBridge,
             platformInstance,
-            bridgeTimeout: 1000,
+            platformId: 'ios',
+            bundleStartTimeout: 1_500,
+            readyTimeout: 2_500,
+            maxAppRestarts: 3,
             testFilePath: '/tmp/test.harness.ts',
             crashSupervisor,
             appLaunchOptions: {
@@ -89,18 +211,189 @@ describe('waitForAppReady', () => {
                 },
             },
         });
-        await Promise.resolve();
-        await vi.advanceTimersByTimeAsync(1000);
-        await expect(promise).rejects.toMatchObject({
-            name: 'AbortError',
-        });
-        expect(restartApp).toHaveBeenCalledTimes(1);
         expect(restartApp).toHaveBeenCalledWith({
             extras: {
                 mode: 'startup',
             },
         });
         await crashSupervisor.dispose();
-        vi.useRealTimers();
+    });
+});
+describe('getHarness', () => {
+    it('routes ensureAppReady through the shared Metro startup helper', async () => {
+        const { serverBridge, emitReady } = createBridgeServer();
+        const appMonitor = createAppMonitor();
+        const restartApp = vi.fn(async () => undefined);
+        const platformInstance = createPlatformRunner({
+            restartApp,
+            createAppMonitor: () => appMonitor.appMonitor,
+        });
+        const metroInstance = createMetroInstance();
+        mocks.getBridgeServer.mockResolvedValue(serverBridge);
+        mocks.getMetroInstance.mockResolvedValue(metroInstance);
+        mocks.waitForMetroBackedAppReady.mockImplementationOnce(async (options) => {
+            await options.startAttempt();
+            const readyPromise = options.waitForReady(new AbortController().signal);
+            emitReady();
+            await readyPromise;
+        });
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = vi.fn(async () => platformInstance);
+        const platform = {
+            config: {
+                appLaunchOptions: {
+                    extras: {
+                        source: 'ensure-ready',
+                    },
+                },
+            },
+            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');
+        await harness.ensureAppReady('/tmp/example.harness.ts');
+        expect(mocks.waitForMetroBackedAppReady).toHaveBeenCalledTimes(1);
+        expect(restartApp).toHaveBeenCalledWith({
+            extras: {
+                source: 'ensure-ready',
+            },
+        });
+        await harness.dispose();
+    });
+    it('routes restart(testFilePath) through the shared Metro startup helper', async () => {
+        const { serverBridge, emitReady } = createBridgeServer();
+        const appMonitor = createAppMonitor();
+        const restartApp = vi.fn(async () => undefined);
+        const stopApp = vi.fn(async () => undefined);
+        const platformInstance = createPlatformRunner({
+            restartApp,
+            stopApp,
+            isAppRunning: vi.fn(async () => false),
+            createAppMonitor: () => appMonitor.appMonitor,
+        });
+        const metroInstance = createMetroInstance();
+        mocks.getBridgeServer.mockResolvedValue(serverBridge);
+        mocks.getMetroInstance.mockResolvedValue(metroInstance);
+        mocks.waitForMetroBackedAppReady.mockImplementationOnce(async (options) => {
+            await options.startAttempt();
+            const readyPromise = options.waitForReady(new AbortController().signal);
+            emitReady();
+            await readyPromise;
+        });
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = vi.fn(async () => platformInstance);
+        const platform = {
+            config: {
+                appLaunchOptions: {
+                    extras: {
+                        source: 'restart',
+                    },
+                },
+            },
+            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');
+        await harness.restart('/tmp/restart.harness.ts');
+        expect(stopApp).toHaveBeenCalledTimes(1);
+        expect(mocks.waitForMetroBackedAppReady).toHaveBeenCalledTimes(1);
+        expect(restartApp).toHaveBeenCalledWith({
+            extras: {
+                source: 'restart',
+            },
+        });
+        await harness.dispose();
+    });
+});
+describe('plugins', () => {
+    it('invokes lifecycle and runtime plugin handlers for configured plugins', async () => {
+        const { serverBridge, emitReady, emitEvent, emitDisconnect } = createBridgeServer();
+        const appMonitor = createAppMonitor();
+        const platformInstance = createPlatformRunner({
+            createAppMonitor: () => appMonitor.appMonitor,
+        });
+        const observedHooks = [];
+        mocks.getBridgeServer.mockResolvedValue(serverBridge);
+        const metroInstance = createMetroInstance();
+        mocks.getMetroInstance.mockResolvedValue(metroInstance);
+        globalThis.__HARNESS_PLATFORM_RUNNER__ = vi.fn(async () => platformInstance);
+        const plugin = definePlugin({
+            name: 'test-plugin',
+            createState: () => ({
+                creationCount: 0,
+            }),
+            hooks: {
+                harness: {
+                    beforeCreation: (ctx) => {
+                        ctx.state.creationCount += 1;
+                        observedHooks.push(`beforeCreation:${ctx.platform.platformId}:${ctx.appLaunchOptions == null ? 'no-launch-options' : 'launch-options'}`);
+                    },
+                    beforeDispose: (ctx) => {
+                        observedHooks.push(`beforeDispose:${ctx.state.creationCount}:${ctx.reason}`);
+                    },
+                },
+                runtime: {
+                    ready: (ctx) => {
+                        observedHooks.push(`runtime.ready:${ctx.runId}:${ctx.device.platform}`);
+                    },
+                    disconnected: (ctx) => {
+                        observedHooks.push(`runtime.disconnected:${ctx.reason}`);
+                    },
+                },
+                collection: {
+                    started: (ctx) => {
+                        observedHooks.push(`collection.started:${ctx.file}`);
+                    },
+                },
+            },
+        });
+        const platform = {
+            config: {
+                appLaunchOptions: {
+                    environment: {
+                        MODE: 'test',
+                    },
+                },
+            },
+            name: 'ios',
+            platformId: 'ios',
+            runner: `data:text/javascript,${encodeURIComponent('export default (...args) => globalThis.__HARNESS_PLATFORM_RUNNER__(...args);')}`,
+        };
+        const harness = await getHarness(createHarnessConfig({
+            plugins: [plugin],
+        }), platform, '/tmp/project');
+        harness.setRunState({
+            runId: 'run-1',
+            startTime: Date.now(),
+            testFiles: ['example.harness.ts'],
+            watchMode: false,
+            coverageEnabled: false,
+            summary: {
+                passed: 1,
+                failed: 0,
+                skipped: 0,
+                todo: 0,
+            },
+            status: 'passed',
+        });
+        emitReady();
+        emitEvent({
+            type: 'collection-started',
+            file: 'example.harness.ts',
+        });
+        emitDisconnect();
+        await harness.dispose();
+        expect(observedHooks).toEqual([
+            'beforeCreation:ios:launch-options',
+            'runtime.ready:run-1:ios',
+            'collection.started:example.harness.ts',
+            'runtime.disconnected:bridge-disconnected',
+            'beforeDispose:1:normal',
+        ]);
+    });
+});
+describe('StartupStallError', () => {
+    it('includes the configured timeout and attempt count', () => {
+        expect(new StartupStallError(1_500, 4).message).toBe('The app did not request its Metro bundle after 4 launch attempts within 1500ms. Last Metro status: unknown.');
     });
 });

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

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

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

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

package/dist/__tests__/index.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from 'vitest';
+import JestHarness from '../index.js';
+import { StartupStallError } from '../errors.js';
+describe('JestHarness', () => {
+    it('reports StartupStallError without a stack trace', async () => {
+        const runner = new JestHarness({});
+        const onFailure = vi.fn();
+        const harness = {
+            ensureAppReady: vi
+                .fn()
+                .mockRejectedValue(new StartupStallError(1500, 3)),
+            callHook: vi.fn(async () => undefined),
+            setRunState: vi.fn(),
+            getRunState: vi.fn(() => null),
+            crashSupervisor: {
+                beginTestRun: vi.fn(),
+                waitForCrash: vi.fn(),
+                cancelCrashWaiters: vi.fn(),
+                reset: vi.fn(),
+            },
+        };
+        await runner._createInBandTestRun([
+            {
+                path: '/tmp/example.harness.ts',
+                context: {
+                    config: {},
+                },
+            },
+        ], {
+            isInterrupted: () => false,
+        }, harness, {
+            detectNativeCrashes: true,
+            resetEnvironmentBetweenTestFiles: false,
+        }, () => Promise.resolve(), () => Promise.resolve(), onFailure);
+        expect(onFailure).toHaveBeenCalledWith(expect.objectContaining({
+            path: '/tmp/example.harness.ts',
+        }), {
+            message: 'The app did not request its Metro bundle after 3 launch attempts within 1500ms. Last Metro status: unknown.',
+            stack: '',
+        });
+    });
+});

package/dist/cli-args.d.ts

@@ -1,5 +1,6 @@
 export type HarnessCliArgs = {
     harnessRunner?: string;
+    metroPort?: number;
 };
 export declare const getAdditionalCliArgs: () => HarnessCliArgs;
 //# sourceMappingURL=cli-args.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cli-args.d.ts","sourceRoot":"","sources":["../src/cli-args.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,cAAc,GAAG;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAO,cAevC,CAAC"}
+{"version":3,"file":"cli-args.d.ts","sourceRoot":"","sources":["../src/cli-args.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,cAAc,GAAG;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAO,cAoBvC,CAAC"}

package/dist/cli-args.js

@@ -5,6 +5,10 @@ export const getAdditionalCliArgs = () => {
         .option('harnessRunner', {
         type: 'string',
         description: 'Specify which Harness runner to use',
+    })
+        .option('metroPort', {
+        type: 'number',
+        description: 'Override the Metro bundler port',
     })
         .strict(false)
         .help(false)
@@ -13,5 +17,6 @@ export const getAdditionalCliArgs = () => {
         .parseSync();
     return {
         harnessRunner: argv.harnessRunner,
+        metroPort: argv.metroPort,
     };
 };

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

@@ -1 +1 @@
-{"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;AAQzC,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,eA6O3B,CAAC"}
+{"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"}

package/dist/crash-supervisor.js

@@ -1,5 +1,6 @@
 import { NativeCrashError, } from './errors.js';
 import { logger } from '@react-native-harness/tools';
+const crashLogger = logger.child('crash');
 const getCrashPhase = (state) => state === 'running' ? 'execution' : 'startup';
 const mergeCrashDetails = (phase, initialDetails, enrichedDetails, fallbackSummary) => ({
     phase,
@@ -43,13 +44,13 @@ export const createCrashSupervisor = ({ appMonitor, platformRunner, }) => {
             return;
         }
         if (!activeTestFilePath) {
-            logger.debug(`Ignoring crash signal without active test: ${reason}`);
+            crashLogger.debug('ignoring crash signal without active test: %s', reason);
             return;
         }
         isResolvingCrash = true;
-        logger.debug(`Native crash detected during ${activeTestFilePath} (state: ${state}, reason: ${reason || '(none)'})`);
+        crashLogger.debug('native crash detected during %s (state=%s reason=%s)', activeTestFilePath, state, reason || '(none)');
         for (const line of details?.rawLines ?? []) {
-            logger.debug(line);
+            crashLogger.debug('%s', line);
         }
         const phase = getCrashPhase(state);
         const testFilePath = activeTestFilePath;
@@ -61,7 +62,7 @@ export const createCrashSupervisor = ({ appMonitor, platformRunner, }) => {
                 occurredAt: Date.now(),
             });
             const mergedDetails = mergeCrashDetails(phase, details, enrichedDetails, reason);
-            logger.debug('Crash details:', {
+            crashLogger.debug('crash details: %o', {
                 phase: mergedDetails.phase,
                 source: mergedDetails.source,
                 summary: mergedDetails.summary,
@@ -83,11 +84,11 @@ export const createCrashSupervisor = ({ appMonitor, platformRunner, }) => {
         try {
             const isRunning = await platformRunner.isAppRunning();
             if (!isRunning) {
-                handleCrash(reason, details);
+                void handleCrash(reason, details);
             }
         }
         catch (error) {
-            logger.debug('Crash confirmation failed', error);
+            crashLogger.debug('crash confirmation failed', error);
         }
     };
     const appMonitorListener = (event) => {

package/dist/errors.d.ts

@@ -1,5 +1,6 @@
 import { HarnessError } from '@react-native-harness/tools';
 import type { AppCrashDetails } from '@react-native-harness/platforms';
+export { StartupStallError, type StartupStallCode, type StartupStallDetails, } from '@react-native-harness/bundler-metro';
 export declare class NoRunnerSpecifiedError extends HarnessError {
     constructor();
 }

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAEvE,qBAAa,sBAAuB,SAAQ,YAAY;;CAKvD;AAED,qBAAa,mBAAoB,SAAQ,YAAY;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAED,qBAAa,0BAA2B,SAAQ,YAAY;;CAK3D;AAED,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,WAAW,CAAC;AAEvD,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG;IACjD,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAsDF,qBAAa,gBAAiB,SAAQ,YAAY;aAE9B,YAAY,EAAE,MAAM;aACpB,OAAO,EAAE,kBAAkB;aAC3B,aAAa,CAAC,EAAE,MAAM;gBAFtB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,kBAAkB,EAC3B,aAAa,CAAC,EAAE,MAAM,YAAA;IAOxC,IAAI,KAAK,qBAER;CACF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EACL,iBAAiB,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,GACzB,MAAM,qCAAqC,CAAC;AAE7C,qBAAa,sBAAuB,SAAQ,YAAY;;CAKvD;AAED,qBAAa,mBAAoB,SAAQ,YAAY;aACvB,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAI/C;AAED,qBAAa,0BAA2B,SAAQ,YAAY;;CAK3D;AAED,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,WAAW,CAAC;AAEvD,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG;IACjD,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAsDF,qBAAa,gBAAiB,SAAQ,YAAY;aAE9B,YAAY,EAAE,MAAM;aACpB,OAAO,EAAE,kBAAkB;aAC3B,aAAa,CAAC,EAAE,MAAM;gBAFtB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,kBAAkB,EAC3B,aAAa,CAAC,EAAE,MAAM,YAAA;IAOxC,IAAI,KAAK,qBAER;CACF"}

package/dist/errors.js

@@ -1,4 +1,5 @@
 import { HarnessError } from '@react-native-harness/tools';
+export { StartupStallError, } from '@react-native-harness/bundler-metro';
 export class NoRunnerSpecifiedError extends HarnessError {
     constructor() {
         super('No runner specified');