@mutineerjs/mutineer 0.9.0 → 0.11.0

package/dist/runner/vitest/__tests__/pool.spec.js

@@ -245,4 +245,715 @@ describe('VitestPool', () => {
         expect(killSpy).toHaveBeenCalledWith(-42000, 'SIGKILL');
         killSpy.mockRestore();
     });
+    /** Helper: create pool, init, emit ready, return {pool, rl} */
+    async function initPool(concurrency = 1, opts = {}) {
+        const pool = new VitestPool({ cwd: '/test', concurrency, ...opts });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        return pool;
+    }
+    /** Helper: shutdown pool and emit ack so it resolves immediately */
+    async function shutdownPool(pool) {
+        const p = pool.shutdown();
+        await new Promise((r) => setImmediate(r));
+        for (const rl of rlEmitters) {
+            rl.emit('line', JSON.stringify({ type: 'shutdown', ok: true }));
+        }
+        await p;
+    }
+    it('handleMessage: ignores empty lines', async () => {
+        const pool = await initPool();
+        rlEmitters[0].emit('line', '');
+        rlEmitters[0].emit('line', '   ');
+        expect(true).toBe(true);
+        await shutdownPool(pool);
+    });
+    it('handleMessage: ignores non-JSON lines', async () => {
+        const pool = await initPool();
+        rlEmitters[0].emit('line', 'some debug output from vitest');
+        expect(true).toBe(true);
+        await shutdownPool(pool);
+    });
+    it('handleMessage: ignores invalid JSON lines', async () => {
+        const pool = await initPool();
+        rlEmitters[0].emit('line', '{invalid json}');
+        expect(true).toBe(true);
+        await shutdownPool(pool);
+    });
+    it('handleMessage: handles result message when no pending task', async () => {
+        const pool = await initPool();
+        // 'result' message with no pending task should be silently ignored
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'result', killed: true, durationMs: 5 }));
+        expect(true).toBe(true);
+        await shutdownPool(pool);
+    });
+    it('handleMessage: handles shutdown message type', async () => {
+        const pool = await initPool();
+        // Emit 'shutdown' type — triggers this.emit('shutdown') on the worker
+        // which the worker's shutdown() handler listens for
+        const shutdownP = pool.shutdown();
+        await new Promise((r) => setImmediate(r));
+        // Instead of shutdown ack, test that 'shutdown' type message is handled
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'shutdown', ok: true }));
+        await shutdownP;
+        expect(true).toBe(true);
+    });
+    it('handleMessage: handles result message with pending task', async () => {
+        const pool = await initPool(1, { timeoutMs: 30000 });
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const runPromise = pool.run(mutant, ['t']);
+        // Wait for acquireWorker to resolve and worker.run() to set pendingTask
+        await new Promise((r) => setImmediate(r));
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'result', killed: true, durationMs: 10 }));
+        const result = await runPromise;
+        expect(result.killed).toBe(true);
+        await shutdownPool(pool);
+    });
+    it('handleMessage: handles result with passingTests field', async () => {
+        const pool = await initPool(1, { timeoutMs: 30000 });
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const runPromise = pool.run(mutant, ['t']);
+        // Wait for acquireWorker to resolve and worker.run() to set pendingTask
+        await new Promise((r) => setImmediate(r));
+        rlEmitters[0].emit('line', JSON.stringify({
+            type: 'result',
+            killed: false,
+            durationMs: 10,
+            passingTests: ['A > b'],
+        }));
+        const result = await runPromise;
+        expect(result.passingTests).toEqual(['A > b']);
+        await shutdownPool(pool);
+    });
+    it('process error event triggers handleExit', async () => {
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1 });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        // Start a run to create a pending task
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const runPromise = pool.run(mutant, ['t']);
+        // Let pool.run advance past acquireWorker so pendingTask is set
+        await new Promise((r) => setImmediate(r));
+        // Emit error on the process — should reject the pending task
+        mockProcesses[0].emit('error', new Error('ENOENT'));
+        await expect(runPromise).rejects.toThrow('Worker exited unexpectedly');
+    });
+    it('process exit event triggers handleExit with code', async () => {
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1 });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const runPromise = pool.run(mutant, ['t']);
+        // Let pool.run advance past acquireWorker so pendingTask is set
+        await new Promise((r) => setImmediate(r));
+        // Emit exit on process — should reject pending task
+        mockProcesses[0].emit('exit', 1);
+        await expect(runPromise).rejects.toThrow('Worker exited unexpectedly');
+    });
+    it('handleExit with no pending task just emits exit', async () => {
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1 });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        // No pending task — process exit should not throw/reject anything
+        mockProcesses[0].emit('exit', 0);
+        expect(true).toBe(true);
+        // Pool handleWorkerExit fires: spawns new process, waits for ready
+        // Give event loop a few ticks to process the restart
+        await new Promise((r) => setImmediate(r));
+        await new Promise((r) => setImmediate(r));
+        // Emit ready for the restarted worker (if it was created)
+        if (rlEmitters.length > 1) {
+            rlEmitters[1].emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+            await new Promise((r) => setImmediate(r));
+        }
+        // Shutdown
+        const shutdownPromise = pool.shutdown();
+        await new Promise((r) => setImmediate(r));
+        // Emit shutdown ack on all readline emitters
+        for (const rl of [...rlEmitters].reverse()) {
+            rl.emit('line', JSON.stringify({ type: 'shutdown', ok: true }));
+        }
+        await shutdownPromise;
+    });
+    it('stderr data handler writes to process.stderr when DEBUG active', async () => {
+        const origDebug = process.env.MUTINEER_DEBUG;
+        process.env.MUTINEER_DEBUG = '1';
+        const stderrSpy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
+        try {
+            const pool = await initPool();
+            // Emit data on stderr
+            mockProcesses[0].stderr.emit('data', Buffer.from('error output'));
+            await shutdownPool(pool);
+        }
+        finally {
+            if (origDebug === undefined)
+                delete process.env.MUTINEER_DEBUG;
+            else
+                process.env.MUTINEER_DEBUG = origDebug;
+            stderrSpy.mockRestore();
+        }
+    });
+    it('kill() with undefined pid falls back to process.kill(SIGKILL)', async () => {
+        const mockProc = new EventEmitter();
+        mockProc.stdout = new EventEmitter();
+        mockProc.stderr = new EventEmitter();
+        mockProc.stdin = { writes: [], write: vi.fn() };
+        mockProc.kill = vi.fn();
+        mockProc.pid = undefined; // pid is undefined — triggers fallback
+        vi.mocked(childProcess.spawn).mockReturnValueOnce(mockProc);
+        const rl = new EventEmitter();
+        vi.mocked(readline.createInterface).mockReturnValueOnce(rl);
+        // Use very short timeout so test doesn't wait long
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1, timeoutMs: 50 });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        rl.emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        // Don't emit a result — let the 50ms timeout fire and call kill()
+        const result = await pool.run(mutant, ['t']);
+        expect(result.error).toBe('timeout');
+        // With pid=undefined, fallback to this.process.kill('SIGKILL')
+        expect(mockProc.kill).toHaveBeenCalledWith('SIGKILL');
+    });
+    it('kill() with process.kill throwing is ignored', async () => {
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1, timeoutMs: 50 });
+        const mockProc = new EventEmitter();
+        mockProc.stdout = new EventEmitter();
+        mockProc.stderr = new EventEmitter();
+        mockProc.stdin = { writes: [], write: vi.fn() };
+        mockProc.kill = vi.fn();
+        mockProc.pid = 99999;
+        vi.mocked(childProcess.spawn).mockReturnValueOnce(mockProc);
+        const rl = new EventEmitter();
+        vi.mocked(readline.createInterface).mockReturnValueOnce(rl);
+        const killSpy = vi.spyOn(process, 'kill').mockImplementation(() => {
+            throw new Error('ESRCH');
+        });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        rl.emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const result = await pool.run(mutant, ['t']);
+        expect(result.error).toBe('timeout');
+        killSpy.mockRestore();
+    });
+    it('pool.run() throws when pool is shutting down', async () => {
+        const pool = new VitestPool({
+            cwd: '/test',
+            concurrency: 1,
+            createWorker: (id) => {
+                const worker = new EventEmitter();
+                worker.id = id;
+                worker.start = vi.fn().mockResolvedValue(undefined);
+                worker.isReady = vi.fn().mockReturnValue(true);
+                worker.isBusy = vi.fn().mockReturnValue(false);
+                worker.run = vi.fn().mockResolvedValue({ killed: true, durationMs: 1 });
+                worker.shutdown = vi.fn().mockResolvedValue(undefined);
+                worker.kill = vi.fn();
+                return worker;
+            },
+        });
+        await pool.init();
+        pool.shutdown(); // Don't await — pool is now shutting down
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        await expect(pool.run(mutant, ['t'])).rejects.toThrow('Pool is shutting down');
+    });
+    it('releaseWorker skips worker that is not ready', async () => {
+        let workerReady = true;
+        const pool = new VitestPool({
+            cwd: '/test',
+            concurrency: 1,
+            createWorker: (id) => {
+                const worker = new EventEmitter();
+                worker.id = id;
+                worker.start = vi.fn().mockResolvedValue(undefined);
+                worker.isReady = vi.fn(() => workerReady);
+                worker.isBusy = vi.fn().mockReturnValue(false);
+                worker.run = vi.fn().mockImplementation(async () => {
+                    workerReady = false;
+                    return { killed: true, durationMs: 1 };
+                });
+                worker.shutdown = vi.fn().mockResolvedValue(undefined);
+                worker.kill = vi.fn();
+                return worker;
+            },
+        });
+        await pool.init();
+        // Run once — worker becomes not ready after run
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const result = await pool.run(mutant, ['t']);
+        expect(result.killed).toBe(true);
+        await pool.shutdown();
+    });
+    it('runWithPool maps timeout result', async () => {
+        const mockPool = {
+            run: vi
+                .fn()
+                .mockResolvedValue({
+                killed: false,
+                durationMs: 10000,
+                error: 'timeout',
+            }),
+        };
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const result = await runWithPool(mockPool, mutant, ['t']);
+        expect(result).toEqual({
+            status: 'timeout',
+            durationMs: 10000,
+            error: 'timeout',
+        });
+    });
+    it('runWithPool maps error result (error with !killed)', async () => {
+        const mockPool = {
+            run: vi
+                .fn()
+                .mockResolvedValue({ killed: false, durationMs: 5, error: 'crash' }),
+        };
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const result = await runWithPool(mockPool, mutant, ['t']);
+        expect(result).toEqual({ status: 'error', durationMs: 5, error: 'crash' });
+    });
+    it('runWithPool maps non-Error exception', async () => {
+        const mockPool = {
+            run: vi.fn().mockRejectedValue('string rejection'),
+        };
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const result = await runWithPool(mockPool, mutant, []);
+        expect(result).toEqual({
+            status: 'error',
+            durationMs: 0,
+            error: 'string rejection',
+        });
+    });
+    it('pool.init() is a no-op when already initialised', async () => {
+        const pool = new VitestPool({
+            cwd: '/test',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = new EventEmitter();
+                w.id = id;
+                w.start = vi.fn().mockResolvedValue(undefined);
+                w.isReady = vi.fn().mockReturnValue(true);
+                w.isBusy = vi.fn().mockReturnValue(false);
+                w.run = vi.fn().mockResolvedValue({ killed: true, durationMs: 1 });
+                w.shutdown = vi.fn().mockResolvedValue(undefined);
+                w.kill = vi.fn();
+                return w;
+            },
+        });
+        await pool.init();
+        const workersBefore = pool.workers.length;
+        await pool.init(); // second call should be no-op
+        expect(pool.workers.length).toBe(workersBefore);
+        await pool.shutdown();
+    });
+    it('pool.shutdown() is a no-op when already shutting down', async () => {
+        const pool = new VitestPool({
+            cwd: '/test',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = new EventEmitter();
+                w.id = id;
+                w.start = vi.fn().mockResolvedValue(undefined);
+                w.isReady = vi.fn().mockReturnValue(true);
+                w.isBusy = vi.fn().mockReturnValue(false);
+                w.run = vi.fn().mockResolvedValue({ killed: true, durationMs: 1 });
+                w.shutdown = vi.fn().mockResolvedValue(undefined);
+                w.kill = vi.fn();
+                return w;
+            },
+        });
+        await pool.init();
+        const p1 = pool.shutdown();
+        const p2 = pool.shutdown(); // second call is a no-op
+        await Promise.all([p1, p2]);
+        expect(true).toBe(true);
+    });
+    it('handleMessage: handles result with nullish killed/durationMs', async () => {
+        const pool = await initPool(1, { timeoutMs: 30000 });
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const runPromise = pool.run(mutant, ['t']);
+        await new Promise((r) => setImmediate(r));
+        // Send result without killed/durationMs to test ?? defaults
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'result' }));
+        const result = await runPromise;
+        expect(result.killed).toBe(true); // ?? true default
+        expect(result.durationMs).toBe(0); // ?? 0 default
+        await shutdownPool(pool);
+    });
+    it('handleMessage: unknown message type is silently ignored', async () => {
+        const pool = await initPool();
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'unknown-type', data: 'whatever' }));
+        expect(true).toBe(true);
+        await shutdownPool(pool);
+    });
+    it('handleExit during shuttingDown skips pendingTask rejection', async () => {
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1 });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        // Start shutdown (sets shuttingDown=true)
+        const shutdownP = pool.shutdown();
+        await new Promise((r) => setImmediate(r));
+        // Emit process exit while shutting down — handleExit called with shuttingDown=true
+        // This covers the FALSE branch of (pendingTask && !shuttingDown)
+        mockProcesses[0].emit('exit', 0);
+        // Emit shutdown ack to resolve the shutdown
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'shutdown', ok: true }));
+        await shutdownP;
+        expect(true).toBe(true);
+    });
+    it('worker.run() throws when not ready', async () => {
+        const pool = new VitestPool({
+            cwd: '/test',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = new EventEmitter();
+                w.id = id;
+                w.start = vi.fn().mockResolvedValue(undefined);
+                w.isReady = vi.fn().mockReturnValue(false); // always not ready
+                w.isBusy = vi.fn().mockReturnValue(false);
+                w.run = vi
+                    .fn()
+                    .mockRejectedValue(new Error(`Worker ${id} is not ready`));
+                w.shutdown = vi.fn().mockResolvedValue(undefined);
+                w.kill = vi.fn();
+                return w;
+            },
+        });
+        await pool.init();
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        await expect(pool.run(mutant, ['t'])).rejects.toThrow('is not ready');
+        await pool.shutdown();
+    });
+    it('worker.run() throws when busy', async () => {
+        const pool = new VitestPool({
+            cwd: '/test',
+            concurrency: 1,
+            createWorker: (id) => {
+                const w = new EventEmitter();
+                w.id = id;
+                w.start = vi.fn().mockResolvedValue(undefined);
+                w.isReady = vi.fn().mockReturnValue(true);
+                w.isBusy = vi.fn().mockReturnValue(true); // busy
+                w.run = vi.fn().mockRejectedValue(new Error(`Worker ${id} is busy`));
+                w.shutdown = vi.fn().mockResolvedValue(undefined);
+                w.kill = vi.fn();
+                return w;
+            },
+        });
+        await pool.init();
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        await expect(pool.run(mutant, ['t'])).rejects.toThrow('is busy');
+        await pool.shutdown();
+    });
+    it('acquireWorker queues second run when single worker is busy', async () => {
+        const pool = await initPool(1, { timeoutMs: 30000 });
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        // Start two runs simultaneously - second must queue since concurrency=1
+        const [run1, run2] = [
+            pool.run(mutant, ['t']),
+            pool.run({ ...mutant, id: '2' }, ['t']),
+        ];
+        // Let both acquireWorker() calls resolve (run1 gets worker, run2 queues)
+        await new Promise((r) => setImmediate(r));
+        // Send result for first run
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'result', killed: true, durationMs: 5 }));
+        await new Promise((r) => setImmediate(r));
+        // After run1 finishes, releaseWorker gives worker to run2
+        // Send result for second run
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'result', killed: false, durationMs: 3 }));
+        const [r1, r2] = await Promise.all([run1, run2]);
+        expect(r1.killed).toBe(true);
+        expect(r2.killed).toBe(false);
+        await shutdownPool(pool);
+    });
+    it('vitestConfig and vitestProject are passed to worker env', async () => {
+        let capturedEnv;
+        vi.mocked(childProcess.spawn).mockImplementationOnce((_cmd, _args, options) => {
+            capturedEnv = options?.env;
+            const proc = new EventEmitter();
+            proc.stdout = new EventEmitter();
+            proc.stderr = new EventEmitter();
+            proc.stdin = { writes: [], write: vi.fn() };
+            proc.kill = vi.fn();
+            return proc;
+        });
+        const rl = new EventEmitter();
+        vi.mocked(readline.createInterface).mockImplementationOnce(() => rl);
+        const pool = new VitestPool({
+            cwd: '/proj',
+            concurrency: 1,
+            vitestConfig: 'vitest.config.ts',
+            vitestProject: 'my-project',
+        });
+        const initP = pool.init();
+        await new Promise((r) => setImmediate(r));
+        expect(capturedEnv?.MUTINEER_VITEST_CONFIG).toBe('vitest.config.ts');
+        expect(capturedEnv?.MUTINEER_VITEST_PROJECT).toBe('my-project');
+        rl.emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initP;
+        const shutdownP = pool.shutdown();
+        await new Promise((r) => setImmediate(r));
+        rl.emit('line', JSON.stringify({ type: 'shutdown', ok: true }));
+        await shutdownP;
+    });
+    it('handleWorkerExit restart failure is silently caught', async () => {
+        let workerNum = 0;
+        const pool = new VitestPool({
+            cwd: '/test',
+            concurrency: 1,
+            createWorker: (id) => {
+                workerNum++;
+                const w = new EventEmitter();
+                w.id = id;
+                w.start =
+                    workerNum === 1
+                        ? vi.fn().mockResolvedValue(undefined)
+                        : vi.fn().mockRejectedValue(new Error('restart failed'));
+                w.isReady = vi.fn().mockReturnValue(workerNum === 1);
+                w.isBusy = vi.fn().mockReturnValue(false);
+                w.run = vi.fn().mockResolvedValue({ killed: true, durationMs: 1 });
+                w.shutdown = vi.fn().mockResolvedValue(undefined);
+                w.kill = vi.fn();
+                return w;
+            },
+        });
+        await pool.init();
+        // Trigger worker exit (pool not shutting down → handleWorkerExit fires)
+        const worker = pool.workers[0];
+        worker.emit('exit', 1);
+        // Give event loop time for handleWorkerExit and failed restart
+        await new Promise((r) => setImmediate(r));
+        await new Promise((r) => setImmediate(r));
+        expect(true).toBe(true); // No uncaught error
+        await pool.shutdown();
+    });
+    it('kill() does nothing when process is already null', async () => {
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1, timeoutMs: 50 });
+        const mockProc = new EventEmitter();
+        mockProc.stdout = new EventEmitter();
+        mockProc.stderr = new EventEmitter();
+        mockProc.stdin = { writes: [], write: vi.fn() };
+        mockProc.kill = vi.fn();
+        mockProc.pid = 12345;
+        vi.mocked(childProcess.spawn).mockReturnValueOnce(mockProc);
+        const rl = new EventEmitter();
+        vi.mocked(readline.createInterface).mockReturnValueOnce(rl);
+        const initP = pool.init();
+        await new Promise((r) => setImmediate(r));
+        rl.emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initP;
+        const killSpy = vi.spyOn(process, 'kill').mockReturnValue(true);
+        // First run: timeout fires, calls kill() (sets process=null, ready=false)
+        const run1 = pool.run({ id: '1', name: 'm', file: 'f', code: 'c', line: 1, col: 1 }, ['t']);
+        const r1 = await run1;
+        expect(r1.error).toBe('timeout');
+        // Pool tries to restart — mock a new spawn that stays alive
+        if (rlEmitters.length > 1) {
+            rlEmitters[1].emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        }
+        killSpy.mockRestore();
+        await pool.shutdown();
+    });
+    it('process exit with null code uses ?? 1 fallback', async () => {
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1 });
+        const initPromise = pool.init();
+        await new Promise((r) => setImmediate(r));
+        rlEmitters[0].emit('line', JSON.stringify({ type: 'ready', workerId: 'w0' }));
+        await initPromise;
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const runPromise = pool.run(mutant, ['t']);
+        await new Promise((r) => setImmediate(r));
+        // Emit exit with null code — triggers `code ?? 1`
+        mockProcesses[0].emit('exit', null);
+        await expect(runPromise).rejects.toThrow('Worker exited unexpectedly with code 1');
+    });
+    it('pool.run() throws when pool not initialised', async () => {
+        const pool = new VitestPool({ cwd: '/test', concurrency: 1 });
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        await expect(pool.run(mutant, ['t'])).rejects.toThrow('Pool not initialised');
+    });
+    it('runWithPool maps killed=true to killed status', async () => {
+        const mockPool = {
+            run: vi.fn().mockResolvedValue({ killed: true, durationMs: 15 }),
+        };
+        const mutant = {
+            id: '1',
+            name: 'm',
+            file: 'f',
+            code: 'c',
+            line: 1,
+            col: 1,
+        };
+        const result = await runWithPool(mockPool, mutant, ['t']);
+        expect(result).toEqual({ status: 'killed', durationMs: 15 });
+    });
+    it('threads passingTests from WorkerMessage through to MutantRunSummary', async () => {
+        const pool = new VitestPool({
+            cwd: process.cwd(),
+            concurrency: 1,
+            timeoutMs: 5000,
+            createWorker: (id) => {
+                const worker = new EventEmitter();
+                worker.id = id;
+                worker.start = vi.fn().mockResolvedValue(undefined);
+                worker.isReady = vi.fn().mockReturnValue(true);
+                worker.isBusy = vi.fn().mockReturnValue(false);
+                worker.run = vi.fn().mockResolvedValue({
+                    killed: false,
+                    durationMs: 10,
+                    passingTests: ['Suite > test one', 'Suite > test two'],
+                });
+                worker.shutdown = vi.fn().mockResolvedValue(undefined);
+                worker.kill = vi.fn();
+                return worker;
+            },
+        });
+        await pool.init();
+        const mutant = {
+            id: 'pt1',
+            name: 'mutant',
+            file: 'foo.ts',
+            code: 'x',
+            line: 1,
+            col: 1,
+        };
+        const result = await pool.run(mutant, ['foo.spec.ts']);
+        expect(result.passingTests).toEqual([
+            'Suite > test one',
+            'Suite > test two',
+        ]);
+        await pool.shutdown();
+    });
 });