@react-native-harness/platform-android 1.2.0 → 1.4.0-rc.1

package/dist/__tests__/app-monitor.test.js

@@ -1,17 +1,7 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { NativeCrashError } from '@react-native-harness/platforms';
 import { createAndroidAppMonitor, createAndroidLogEvent } from '../app-monitor.js';
-import { createCrashArtifactWriter } from '@react-native-harness/tools';
 import * as adb from '../adb.js';
-const createMockSubprocess = () => ({
-    nodeChildProcess: Promise.resolve({
-        kill: vi.fn(),
-    }),
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    [Symbol.asyncIterator]: async function* () { },
-});
 const createStreamingSubprocess = (chunks) => ({
     nodeChildProcess: Promise.resolve({
         kill: vi.fn(),
@@ -25,155 +15,243 @@ const createStreamingSubprocess = (chunks) => ({
         }
     },
 });
-const artifactRoot = fs.mkdtempSync(path.join(tmpdir(), 'rn-harness-android-monitor-artifacts-'));
-afterEach(() => {
-    fs.rmSync(artifactRoot, { recursive: true, force: true });
-    fs.mkdirSync(artifactRoot, { recursive: true });
-});
 describe('createAndroidLogEvent', () => {
-    it('extracts crash details from fatal signal log lines', () => {
-        const event = createAndroidLogEvent('03-12 11:35:08.000  1234  1234 F libc    : Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR) in tid 1234 (com.harnessplayground), pid 1234 (com.harnessplayground)', 'com.harnessplayground');
+    it('detects confirmation-grade am_crash events', () => {
+        const event = createAndroidLogEvent('05-20 12:00:00.200  1000  1000 I am_crash: [0,1234,com.harnessplayground,123,java.lang.IllegalStateException,boom]', 'com.harnessplayground');
         expect(event).toMatchObject({
-            type: 'possible_crash',
-            source: 'logs',
+            type: 'crash_confirmed',
             crashDetails: {
+                platform: 'android',
+                kind: 'java-exception',
+                confidence: 'high',
                 source: 'logs',
-                signal: 'SIGSEGV',
-                summary: '03-12 11:35:08.000  1234  1234 F libc    : Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR) in tid 1234 (com.harnessplayground), pid 1234 (com.harnessplayground)',
             },
         });
     });
-    it('extracts process and pid when AndroidRuntime reports a crash', () => {
-        const event = createAndroidLogEvent('03-12 11:35:09.000  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234', 'com.harnessplayground');
-        expect(event).toMatchObject({
-            type: 'possible_crash',
-            pid: 1234,
-            crashDetails: {
-                processName: 'com.harnessplayground',
-                pid: 1234,
-            },
-        });
+});
+describe('createAndroidAppMonitor', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        vi.useFakeTimers();
+        vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('05-20 12:00:00.000');
+    });
+    afterEach(() => {
+        vi.useRealTimers();
     });
-    it('starts logcat from the current device timestamp', async () => {
-        const getLogcatTimestampSpy = vi
-            .spyOn(adb, 'getLogcatTimestamp')
-            .mockResolvedValue('03-12 11:35:08.000');
-        const startLogcatSpy = vi
+    it('starts logcat with crash, main, system, and events buffers', async () => {
+        const startLogcat = vi
             .spyOn(adb, 'startLogcat')
-            .mockReturnValue(createMockSubprocess());
+            .mockReturnValue(createStreamingSubprocess([]));
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
             appUid: 10234,
+            isAppRunning: async () => true,
         });
         await monitor.start();
         await monitor.stop();
-        expect(getLogcatTimestampSpy).toHaveBeenCalledWith('emulator-5554');
-        expect(startLogcatSpy).toHaveBeenCalledWith('emulator-5554', [
+        expect(startLogcat).toHaveBeenCalledWith('emulator-5554', [
             'logcat',
-            '-v',
-            'threadtime',
             '-b',
             'crash',
-            '--uid=10234',
+            '-b',
+            'main',
+            '-b',
+            'system',
+            '-b',
+            'events',
+            '-v',
+            'threadtime',
             '-T',
-            '03-12 11:35:08.000',
+            '05-20 12:00:00.000',
         ]);
     });
-    it('hydrates crash details with stack lines that arrive after the first crash event', async () => {
-        vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('03-12 10:44:40.000');
+    it('reports app lifecycle and crash events through the reporter', async () => {
+        vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([
+            {
+                line: '05-20 12:00:00.000  1234  1234 I ActivityManager: Start proc 1234:com.harnessplayground/u0a123 for activity',
+            },
+            {
+                line: '05-20 12:00:00.100  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
+            },
+            {
+                line: '05-20 12:00:00.200  1000  1000 I am_crash: [0,1234,com.harnessplayground,123,java.lang.IllegalStateException,boom]',
+            },
+        ]));
+        const eventReporter = vi.fn();
+        const monitor = createAndroidAppMonitor({
+            adbId: 'emulator-5554',
+            bundleId: 'com.harnessplayground',
+            appUid: 10234,
+            isAppRunning: async () => true,
+            eventReporter,
+        });
+        const crashWatch = monitor.watch('example.test.ts', 'startup');
+        crashWatch.promise.catch(() => undefined);
+        monitor.launchRequested({
+            type: 'launch_requested',
+            launchId: 'launch-1',
+            at: Date.now(),
+            reason: 'start',
+        });
+        await monitor.start();
+        await vi.advanceTimersByTimeAsync(100);
+        expect(eventReporter).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'app:started',
+            appPlatform: 'android',
+            targetIdentifier: 'emulator-5554',
+            launchId: 'launch-1',
+        }));
+        expect(eventReporter).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'app:crash-suspected',
+            appPlatform: 'android',
+            processName: 'com.harnessplayground',
+        }));
+        expect(eventReporter).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'app:crash-confirmed',
+            appPlatform: 'android',
+            processName: 'com.harnessplayground',
+        }));
+        await monitor.stop();
+    });
+    it('rejects the watch for Java crashes when am_crash arrives even if the process still looks alive', async () => {
         vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([
-            { line: '--------- beginning of crash' },
             {
-                line: '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
+                line: '05-20 12:00:00.000  1234  1234 I ActivityManager: Start proc 1234:com.harnessplayground/u0a123 for activity',
             },
             {
-                line: '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
-                delayMs: 25,
+                line: '05-20 12:00:00.100  1234  1234 E AndroidRuntime: FATAL EXCEPTION: main',
             },
             {
-                line: '03-12 10:44:40.422 13861 13861 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
-                delayMs: 25,
+                line: '05-20 12:00:00.101  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
+            },
+            {
+                line: '05-20 12:00:00.102  1234  1234 E AndroidRuntime: java.lang.IllegalStateException: Intentional pre-RN startup crash',
+            },
+            {
+                line: '05-20 12:00:00.103  1234  1234 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
+            },
+            {
+                line: '05-20 12:00:00.200  1000  1000 I am_crash: [0,1234,com.harnessplayground,123,java.lang.IllegalStateException,Intentional pre-RN startup crash]',
             },
         ]));
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
             appUid: 10234,
+            isAppRunning: async () => true,
         });
+        const crashWatch = monitor.watch('example.test.ts', 'startup');
+        crashWatch.promise.catch(() => undefined);
         await monitor.start();
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        const details = await monitor.getCrashDetails({
-            pid: 13861,
-            occurredAt: Date.now(),
+        await vi.advanceTimersByTimeAsync(100);
+        await expect(crashWatch.promise).rejects.toMatchObject({
+            testFilePath: 'example.test.ts',
+            details: {
+                phase: 'startup',
+                platform: 'android',
+                kind: 'java-exception',
+                confidence: 'high',
+                processName: 'com.harnessplayground',
+                pid: 1234,
+                exceptionType: 'java.lang.IllegalStateException: Intentional pre-RN startup crash',
+            },
         });
+        await expect(crashWatch.promise).rejects.toBeInstanceOf(NativeCrashError);
         await monitor.stop();
-        expect(details?.rawLines).toEqual([
-            '--------- beginning of crash',
-            '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
-            '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
-            '03-12 10:44:40.422 13861 13861 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
-        ]);
     });
-    it('persists resolved Android crash blocks into .harness', async () => {
-        vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('03-12 10:44:40.000');
+    it('rejects the watch when a suspected crash is followed by process exit', async () => {
         vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([
-            { line: '--------- beginning of crash' },
             {
-                line: '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
+                line: '05-20 12:00:00.101  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
             },
             {
-                line: '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
-                delayMs: 20,
+                line: '05-20 12:00:00.102  1234  1234 E AndroidRuntime: java.lang.IllegalStateException: Intentional delayed startup crash',
             },
         ]));
+        const isAppRunning = vi
+            .fn()
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(false)
+            .mockResolvedValue(false);
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
             appUid: 10234,
-            crashArtifactWriter: createCrashArtifactWriter({
-                runnerName: 'android',
-                platformId: 'android',
-                rootDir: path.join(artifactRoot, '.harness', 'crash-reports'),
-                runTimestamp: '2026-03-12T11-35-08-000Z',
-            }),
+            isAppRunning,
         });
+        const crashWatch = monitor.watch('example.test.ts', 'execution');
+        crashWatch.promise.catch(() => undefined);
         await monitor.start();
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        const details = await monitor.getCrashDetails({
-            pid: 13861,
-            occurredAt: Date.now(),
+        await vi.advanceTimersByTimeAsync(350);
+        await expect(crashWatch.promise).rejects.toMatchObject({
+            details: {
+                phase: 'execution',
+                platform: 'android',
+                kind: 'java-exception',
+                processName: 'com.harnessplayground',
+                pid: 1234,
+            },
         });
         await monitor.stop();
-        expect(details?.artifactPath).toContain('/.harness/crash-reports/');
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        expect(fs.readFileSync(details.artifactPath, 'utf8')).toContain('RuntimeException: boom');
     });
-    it('can be started again after timestamp lookup fails', async () => {
-        const timestampError = new Error('date failed');
-        vi.spyOn(adb, 'getLogcatTimestamp')
-            .mockRejectedValueOnce(timestampError)
-            .mockResolvedValueOnce('03-12 11:35:08.000');
-        const startLogcatSpy = vi
-            .spyOn(adb, 'startLogcat')
-            .mockReturnValue(createMockSubprocess());
+    it('does not reject the watch when the process exits without a recent crash signal', async () => {
+        vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([]));
+        const isAppRunning = vi
+            .fn()
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(false)
+            .mockResolvedValue(false);
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
             appUid: 10234,
+            isAppRunning,
+        });
+        const crashWatch = monitor.watch('example.test.ts', 'execution');
+        let settled = false;
+        const watchHandled = crashWatch.promise.catch(() => {
+            settled = true;
         });
-        await expect(monitor.start()).rejects.toThrow(timestampError);
-        await expect(monitor.start()).resolves.toBeUndefined();
+        await monitor.start();
+        await vi.advanceTimersByTimeAsync(600);
+        expect(settled).toBe(false);
+        crashWatch.cancel();
         await monitor.stop();
-        expect(startLogcatSpy).toHaveBeenCalledWith('emulator-5554', [
-            'logcat',
-            '-v',
-            'threadtime',
-            '-b',
-            'crash',
-            '--uid=10234',
-            '-T',
-            '03-12 11:35:08.000',
-        ]);
+        await watchHandled;
+    });
+    it('suppresses process-exit confirmation during a controlled stop window', async () => {
+        vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([
+            {
+                line: '05-20 12:00:00.101  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
+            },
+        ]));
+        const isAppRunning = vi
+            .fn()
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(false)
+            .mockResolvedValue(false);
+        const monitor = createAndroidAppMonitor({
+            adbId: 'emulator-5554',
+            bundleId: 'com.harnessplayground',
+            appUid: 10234,
+            isAppRunning,
+        });
+        const crashWatch = monitor.watch('example.test.ts', 'execution');
+        let settled = false;
+        const watchHandled = crashWatch.promise.catch(() => {
+            settled = true;
+        });
+        await monitor.start();
+        monitor.stopRequested({
+            type: 'stop_requested',
+            at: Date.now(),
+            reason: 'manual',
+        });
+        await vi.advanceTimersByTimeAsync(400);
+        expect(settled).toBe(false);
+        crashWatch.cancel();
+        await monitor.stop();
+        await watchHandled;
     });
 });

package/dist/__tests__/crash-diagnostics.test.d.ts

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

package/dist/__tests__/crash-diagnostics.test.d.ts.map

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

package/dist/__tests__/crash-diagnostics.test.js

@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'vitest';
+import { collectDropboxArtifacts, filterExitInfo, getBestDropboxArtifact, parseDropboxOutput, } from '../crash-diagnostics.js';
+const javaCrashDropbox = `
+Drop box contents: 1 entries
+Max entries: 1000
+========================================
+2026-03-12 10:30:45.123 data_app_crash (text, 500 bytes)
+Process: com.harnessplayground
+PID: 7777
+Package: com.harnessplayground v1 (1.0)
+java.lang.RuntimeException: boom
+\tat com.harnessplayground.MainActivity.onCreate(MainActivity.kt:38)
+`;
+const nativeCrashDropbox = `
+========================================
+2026-03-12 10:31:10.456 data_app_native_crash (text, 800 bytes)
+Process: com.harnessplayground
+PID: 8888
+signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0xdeadbeef
+Abort message: 'JNI DETECTED ERROR IN APPLICATION'
+backtrace:
+      #00 pc 00001234  /data/app/lib/libapp.so
+`;
+const deviceJavaCrashDropbox = `
+Drop box contents: 8 entries
+Searching for: data_app_crash
+
+========================================
+2026-05-29 10:22:34 data_app_crash (text, 1328 bytes)
+SystemUptimeMs: 79467172
+Process: com.harnessplayground
+PID: 586
+Package: com.harnessplayground v1 (1.0)
+java.lang.RuntimeException: Intentional asynchronous Kotlin crash
+\tat com.harnessplayground.PlaygroundCrashModule.crashFromKotlinAsync(PlaygroundCrashModule.kt:44)
+`;
+describe('collectDropboxArtifacts', () => {
+    it('matches harness playground crashes from merged per-tag dropbox output', async () => {
+        const artifacts = await collectDropboxArtifacts({
+            bundleId: 'com.harnessplayground',
+            getDropboxOutput: async () => deviceJavaCrashDropbox,
+            occurredAt: Date.now(),
+            pid: 586,
+        });
+        expect(artifacts).toHaveLength(1);
+        expect(artifacts[0]).toMatchObject({
+            artifactType: 'dropbox-crash',
+            pid: 586,
+            processName: 'com.harnessplayground',
+        });
+    });
+    it('ignores Dropbox entries older than the session start time', async () => {
+        const artifacts = await collectDropboxArtifacts({
+            bundleId: 'com.harnessplayground',
+            getDropboxOutput: async () => deviceJavaCrashDropbox,
+            minOccurredAt: Date.parse('2026-05-29T10:22:35.000Z'),
+            occurredAt: Date.parse('2026-05-29T10:22:36.000Z'),
+        });
+        expect(artifacts).toHaveLength(0);
+    });
+});
+describe('parseDropboxOutput', () => {
+    it('parses java and native dropbox entries', () => {
+        const entries = parseDropboxOutput(`${javaCrashDropbox}\n${nativeCrashDropbox}`);
+        expect(entries).toHaveLength(2);
+        expect(entries[0]).toMatchObject({
+            tag: 'data_app_crash',
+            pid: 7777,
+        });
+        expect(entries[1]).toMatchObject({
+            tag: 'data_app_native_crash',
+            pid: 8888,
+        });
+        expect(entries[1]?.content).toContain('SIGSEGV');
+    });
+});
+describe('getBestDropboxArtifact', () => {
+    it('prefers the highest-scored artifact', () => {
+        const entries = parseDropboxOutput(`${javaCrashDropbox}\n${nativeCrashDropbox}`);
+        const artifacts = entries.map((entry, index) => ({
+            artifactType: entry.tag === 'data_app_native_crash'
+                ? 'dropbox-native-crash'
+                : 'dropbox-crash',
+            dropboxTag: entry.tag,
+            occurredAt: Date.now(),
+            score: index === 0 ? 100 : 300,
+            summary: entry.content,
+            pid: entry.pid,
+            processName: 'com.harnessplayground',
+        }));
+        expect(getBestDropboxArtifact(artifacts)?.dropboxTag).toBe('data_app_native_crash');
+    });
+});
+describe('filterExitInfo', () => {
+    it('returns matching exit-info records for the target package and pid', () => {
+        const output = `
+ApplicationExitInfo #0:
+  package=com.harnessplayground pid=7777 realUid=10123
+  reason=4 (APP CRASH(NATIVE))
+  timestamp=2026-03-12 10:31:10.456
+ApplicationExitInfo #1:
+  package=com.other.app pid=9999 realUid=10199
+  reason=10 (USER REQUESTED)
+`;
+        const filtered = filterExitInfo({
+            output,
+            bundleId: 'com.harnessplayground',
+            pid: 7777,
+        });
+        expect(filtered).toContain('com.harnessplayground pid=7777');
+        expect(filtered).not.toContain('com.other.app');
+    });
+    it('returns null when no exit-info records exist', () => {
+        expect(filterExitInfo({
+            output: 'No exit info records for com.harnessplayground',
+            bundleId: 'com.harnessplayground',
+        })).toBeNull();
+    });
+});

package/dist/__tests__/crash-reporter.test.d.ts

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

package/dist/__tests__/crash-reporter.test.d.ts.map

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

package/dist/__tests__/crash-reporter.test.js

@@ -0,0 +1,150 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createAndroidCrashReporter } from '../crash-reporter.js';
+const javaCrashDropbox = `
+========================================
+2026-03-12 10:30:45.123 data_app_crash (text, 500 bytes)
+Process: com.harnessplayground
+PID: 7777
+Package: com.harnessplayground v1 (1.0)
+java.lang.RuntimeException: boom
+\tat com.harnessplayground.MainActivity.onCreate(MainActivity.kt:38)
+`;
+const nativeCrashDropbox = `
+========================================
+2026-03-12 10:31:10.456 data_app_native_crash (text, 800 bytes)
+Process: com.harnessplayground
+PID: 8888
+signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0xdeadbeef
+Abort message: 'JNI DETECTED ERROR IN APPLICATION'
+backtrace:
+      #00 pc 00001234  /data/app/lib/libapp.so
+`;
+describe('createAndroidCrashReporter', () => {
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('persists the current logcat crash block with the test file path', async () => {
+        vi.useFakeTimers();
+        const persistArtifact = vi.fn(() => '/tmp/.harness/crash-reports/logcat.txt');
+        const reporter = createAndroidCrashReporter({
+            bundleId: 'com.harnessplayground',
+            crashArtifactWriter: {
+                runTimestamp: '2026-03-12T11-35-08-000Z',
+                persistArtifact,
+            },
+            getLogs: () => [
+                { line: 'ordinary crash-buffer line', occurredAt: 1_000 },
+                { line: '--------- beginning of crash', occurredAt: 1_100 },
+                {
+                    line: 'Process: com.harnessplayground, PID: 7777',
+                    occurredAt: 1_100,
+                },
+                { line: 'FATAL EXCEPTION: main', occurredAt: 1_100 },
+            ],
+        });
+        const detailsPromise = reporter.getCrashDetails({
+            occurredAt: 1_100,
+            pid: 7777,
+            testFilePath: '/test/native-crash.test.ts',
+        });
+        await vi.advanceTimersByTimeAsync(100);
+        const details = await detailsPromise;
+        expect(details).toMatchObject({
+            artifactType: 'logcat',
+            artifactPath: '/tmp/.harness/crash-reports/logcat.txt',
+            pid: 7777,
+            processName: 'com.harnessplayground',
+        });
+        expect(persistArtifact).toHaveBeenCalledWith({
+            artifactKind: 'logcat',
+            testFilePath: '/test/native-crash.test.ts',
+            source: {
+                kind: 'text',
+                fileName: 'logcat.txt',
+                text: [
+                    '--------- beginning of crash',
+                    'Process: com.harnessplayground, PID: 7777',
+                    'FATAL EXCEPTION: main',
+                    '',
+                ].join('\n'),
+            },
+        });
+    });
+    it('adds dropbox artifacts as enrichment when logcat evidence is available', async () => {
+        vi.useFakeTimers();
+        const persistArtifact = vi
+            .fn()
+            .mockImplementation(({ artifactKind }) => {
+            return `/tmp/.harness/crash-reports/${artifactKind}.txt`;
+        });
+        const reporter = createAndroidCrashReporter({
+            bundleId: 'com.harnessplayground',
+            crashArtifactWriter: {
+                runTimestamp: '2026-03-12T11-35-08-000Z',
+                persistArtifact,
+            },
+            getLogs: () => [
+                { line: '--------- beginning of crash', occurredAt: 1_100 },
+                {
+                    line: 'Process: com.harnessplayground, PID: 7777',
+                    occurredAt: 1_100,
+                },
+                { line: 'FATAL EXCEPTION: main', occurredAt: 1_100 },
+            ],
+            getDropboxOutput: async () => javaCrashDropbox,
+            getExitInfo: async () => 'ApplicationExitInfo #0:\n  package=com.harnessplayground pid=7777 reason=4 (APP CRASH(NATIVE))',
+        });
+        const detailsPromise = reporter.getCrashDetails({
+            occurredAt: 1_100,
+            pid: 7777,
+            testFilePath: '/test/native-crash.test.ts',
+        });
+        await vi.advanceTimersByTimeAsync(100);
+        const details = await detailsPromise;
+        expect(details).toMatchObject({
+            artifactType: 'logcat',
+            artifactPath: '/tmp/.harness/crash-reports/logcat.txt',
+        });
+        expect(details?.enrichmentArtifacts).toEqual(expect.arrayContaining([
+            {
+                artifactType: 'dropbox-crash',
+                artifactPath: '/tmp/.harness/crash-reports/dropbox-crash.txt',
+            },
+            {
+                artifactType: 'exit-info',
+                artifactPath: '/tmp/.harness/crash-reports/exit-info.txt',
+            },
+        ]));
+    });
+    it('falls back to native dropbox evidence when logcat is empty', async () => {
+        vi.useFakeTimers();
+        const persistArtifact = vi
+            .fn()
+            .mockImplementation(({ artifactKind }) => {
+            return `/tmp/.harness/crash-reports/${artifactKind}.txt`;
+        });
+        const reporter = createAndroidCrashReporter({
+            bundleId: 'com.harnessplayground',
+            crashArtifactWriter: {
+                runTimestamp: '2026-03-12T11-35-08-000Z',
+                persistArtifact,
+            },
+            getLogs: () => [],
+            getDropboxOutput: async () => nativeCrashDropbox,
+        });
+        const detailsPromise = reporter.getCrashDetails({
+            occurredAt: 1_100,
+            pid: 8888,
+            testFilePath: '/test/native-crash.test.ts',
+        });
+        await vi.advanceTimersByTimeAsync(100);
+        const details = await detailsPromise;
+        expect(details).toMatchObject({
+            artifactType: 'dropbox-native-crash',
+            artifactPath: '/tmp/.harness/crash-reports/dropbox-native-crash.txt',
+            pid: 8888,
+            signal: 'SIGSEGV',
+            processName: 'com.harnessplayground',
+        });
+    });
+});