oxmutate 1.2.5 → 1.3.0

package/dist/coordinator.d.ts

@@ -62,6 +62,8 @@ export interface RunStats {
     flakyMutants: number;
     units: number;
     serversSpawned: number;
+    /** Mutants whose Timeout their worker called itself, the wait able to end by nothing (quiescence.ts): no watchdog wait, no respawn. */
+    deadlocks: number;
 }
 export interface RunResult {
     root: string;
@@ -86,4 +88,11 @@ export interface RunResult {
 }
 export declare class InstrumentFault extends Error {
 }
+/**
+ * No single test execution is waited on past this (owner, 2026-11-04: "we should not wait longer than
+ * that"). Every watchdog budget is capped at it per test the run executes, the 3x re-run of a busy stop
+ * included. A hang is mostly called by its worker in about half a second (quiescence.ts); the cap
+ * bounds the waits it cannot judge.
+ */
+export declare const MAX_TEST_MS = 5000;
 export declare function run(options: Options): Promise<RunResult>;

package/dist/coordinator.js

@@ -27,7 +27,16 @@ function readRecords(file) {
 }
 const sha = (s) => createHash('sha256').update(s).digest('hex').slice(0, 16);
 const UNIT_PAIRS = 400;
+const DEADLOCK_REASON = 'its test deadlocked: nothing left in the worker could resume it (a hang, called in under a second)';
+function timeoutReason(v) {
+    if (v.deadlock)
+        return DEADLOCK_REASON;
+    if (v.idle)
+        return 'its test waited past the budget with the worker idle: a hang, not a slow test';
+    return 'stopped by the watchdog twice, the second time with 3x the budget';
+}
 const RERUN_SLACK = 3;
+export const MAX_TEST_MS = 5000;
 const MS_PER_MINUTE = 60_000;
 const PERCENT = 100;
 const allCovering = (m) => [...m.coveredBy, ...(m.specCoveredBy ?? [])];
@@ -44,7 +53,7 @@ export async function run(options) {
     const work = mkdtempSync(path.join(tmpdir(), 'oxmutate-'));
     const stats = {
         files: 0, mutants: 0, instrumentMs: 0, dryRunMs: 0, mutationMs: 0, staticMs: 0, staticRecollections: 0, isolatedMs: 0, wallMs: 0, testExecutions: 0,
-        watchdogKills: 0, idleStalls: 0, crashes: 0, canaryFiles: 0, pollutionRestarts: 0, survivorsOverturned: 0, timeoutsOverturned: 0, compileErrors: 0, isolatedRuns: 0, reused: 0, flakyTests: 0, flakyMutants: 0, units: 0, serversSpawned: 0,
+        watchdogKills: 0, idleStalls: 0, deadlocks: 0, crashes: 0, canaryFiles: 0, pollutionRestarts: 0, survivorsOverturned: 0, timeoutsOverturned: 0, compileErrors: 0, isolatedRuns: 0, reused: 0, flakyTests: 0, flakyMutants: 0, units: 0, serversSpawned: 0,
     };
     let unitSeq = 0;
     const fileFor = (kind, ext) => path.join(work, `${kind}-${String(unitSeq++)}.${ext}`);
@@ -272,7 +281,7 @@ export async function run(options) {
         const hitLimitOf = (id) => Math.max(1000, (hits.get(id) ?? 1) * 100);
         const hitLimits = Object.fromEntries(toRun.map((m) => [m.id, hitLimitOf(m.id)]));
         const maxTestMs = (id) => { const m = byId.get(id); return Math.max(0, ...(m ? allCovering(m) : []).map((t) => testInfo.get(t)?.ms ?? 0)); };
-        const warmBudget = (id) => options.timeoutMS + Math.max(options.timeoutFactor, 3) * maxTestMs(id) + 250;
+        const warmBudget = (id) => Math.min(MAX_TEST_MS, options.timeoutMS + Math.max(options.timeoutFactor, 3) * maxTestMs(id) + 250);
         const fileOrder = new Map();
         for (const m of toRun) {
             const cost = new Map();
@@ -283,11 +292,12 @@ export async function run(options) {
             }
             fileOrder.set(m.id, [...cost].sort((a, b) => a[1] - b[1]).map(([f]) => f));
         }
+        const testMsOf = (plan) => Object.fromEntries(Object.keys(plan).map((t) => [t, testInfo.get(t)?.ms ?? 0]));
         const planUnits = new Map();
         const unfinished = new Set();
         const makeUnit = (file, plan, depth = 0) => {
             const unit = { mode: 'mutant', files: [file], results: fileFor('unit', 'jsonl'), progress: fileFor('unit', 'progress'), plan: fileFor('plan', 'json') };
-            writeFileSync(unit.plan, JSON.stringify({ tests: plan, hitLimits, skip: [], specTests: [...specOf.keys()], runOnce: dry.runOnce }));
+            writeFileSync(unit.plan, JSON.stringify({ tests: plan, hitLimits, skip: [], specTests: [...specOf.keys()], runOnce: dry.runOnce, testMs: testMsOf(plan) }));
             planUnits.set(unit.results, { file, plan, depth });
             stats.units++;
             return unit;
@@ -384,7 +394,7 @@ export async function run(options) {
             if (Object.keys(left).length === 0)
                 return false;
             entry.plan = left;
-            writeFileSync(unit.plan, JSON.stringify({ tests: left, hitLimits, skip: [], specTests: [...specOf.keys()], runOnce: dry.runOnce }));
+            writeFileSync(unit.plan, JSON.stringify({ tests: left, hitLimits, skip: [], specTests: [...specOf.keys()], runOnce: dry.runOnce, testMs: testMsOf(left) }));
             return true;
         };
         await pool.drain(unitsForRound(toRun, (m) => fileOrder.get(m.id) ?? []), (_, id) => warmBudget(id), afterUnit, beforeUnit);
@@ -414,6 +424,8 @@ export async function run(options) {
             }
             else if (killers.length) {
                 m.status = killers.some((r) => r.status === 'Killed') ? 'Killed' : 'Timeout';
+                if (m.status === 'Timeout' && killers.some((r) => r.deadlock))
+                    m.statusReason = DEADLOCK_REASON;
                 m.killedBy = [...new Set(killers.map((r) => r.test ?? ''))];
                 m.testsCompleted = recs.length;
             }
@@ -452,13 +464,20 @@ export async function run(options) {
             const covering = byCost([...new Set(tests)]);
             return [...covering, ...byAffinity(m.file, [...loaders].filter((f) => !covering.includes(f)))];
         };
+        const testsRun = (id) => {
+            const m = byId.get(id);
+            const fs = m ? filesFor(m) : allTestFiles;
+            const covering = new Set(m && !m.static ? m.coveredBy : []);
+            return Math.max(1, dry.tests.filter((t) => fs.includes(t.file) && (covering.size === 0 || covering.has(t.id))).length);
+        };
         const isolatedBudget = (id) => {
             const m = byId.get(id);
             const fs = m ? filesFor(m) : allTestFiles;
             const covering = new Set(m && !m.static ? m.coveredBy : []);
             const ms = dry.tests.filter((t) => fs.includes(t.file) && (covering.size === 0 || covering.has(t.id))).reduce((sum, t) => sum + t.ms, 0);
-            return 1500 + options.timeoutMS + options.timeoutFactor * ms * 2;
+            return Math.min(MAX_TEST_MS * testsRun(id), 1500 + options.timeoutMS + options.timeoutFactor * ms * 2);
         };
+        const isolatedCapped = (id, slack) => Math.min(slack * isolatedBudget(id), MAX_TEST_MS * testsRun(id));
         const decideStaticLive = async (items) => {
             if (items.length === 0)
                 return [];
@@ -512,7 +531,7 @@ export async function run(options) {
             const open = (m) => !killed.has(m.id) && !back.has(m.id);
             const rounds = [(m) => filesFor(m).slice(0, 1), (m) => (open(m) ? filesFor(m).slice(1) : [])];
             for (const round of rounds)
-                await staticPool.drain(unitsFor(round), (_, id) => 2 * isolatedBudget(id), afterStatic, keepUndecided);
+                await staticPool.drain(unitsFor(round), (_, id) => isolatedCapped(id, 2), afterStatic, keepUndecided);
             const undecided = [];
             for (const m of items) {
                 const k = killed.get(m.id);
@@ -544,14 +563,14 @@ export async function run(options) {
             }
             const units = bins.sort((x, y) => y.load - x.load).map((b) => mk(b.batch));
             stats.isolatedRuns += items.length;
-            await pool.drain(units, (_, id) => slack * isolatedBudget(id), (unit, outcome) => {
+            await pool.drain(units, (_, id) => isolatedCapped(id, slack), (unit, outcome) => {
                 for (const rec of readRecords(unit.results)) {
                     if (rec.type !== 'isolated' || !rec.id)
                         continue;
                     const prev = verdicts.get(rec.id);
                     const testsCompleted = (prev?.testsCompleted ?? 0) + (rec.ran ?? 0);
                     if (rec.timeout)
-                        verdicts.set(rec.id, { status: 'Timeout', testsCompleted });
+                        verdicts.set(rec.id, { status: 'Timeout', testsCompleted, ...(rec.deadlock && { idle: true, deadlock: true }) });
                     else if (rec.killed)
                         verdicts.set(rec.id, { status: 'Killed', killedBy: [...(prev?.killedBy ?? []), ...(rec.failed ?? [])], testsCompleted });
                     else
@@ -595,7 +614,7 @@ export async function run(options) {
                 m.killedBy = v.killedBy;
                 m.testsCompleted = v.testsCompleted;
                 if (v.status === 'Timeout')
-                    m.statusReason = v.idle ? 'its test waited past the budget with the worker idle: a hang, not a slow test' : 'stopped by the watchdog twice, the second time with 3x the budget';
+                    m.statusReason = timeoutReason(v);
             }
         }
         const survivors = toRun.filter((m) => m.status === 'Survived' && new Set(m.coveredBy).size > 1);
@@ -651,6 +670,7 @@ export async function run(options) {
         stats.isolatedMs = performance.now() - i0;
         stats.watchdogKills = pool.stats.killed;
         stats.idleStalls = pool.stats.idle;
+        stats.deadlocks = mutants.filter((m) => m.statusReason === DEADLOCK_REASON).length;
         stats.crashes = pool.stats.crashed;
         if (options.incremental) {
             mkdirSync(path.dirname(options.incrementalFile), { recursive: true });

package/dist/quiescence.js

@@ -0,0 +1,189 @@
+import { syncBuiltinESMExports } from 'node:module';
+import { performance } from 'node:perf_hooks';
+import timers from 'node:timers';
+import promiseTimers from 'node:timers/promises';
+import { promisify } from 'node:util';
+import { env, stderr } from './runtime.js';
+export const SAMPLE_MS = 100;
+export const QUIET_SELF_SHARE = 0.05;
+export const QUIET_OTHER_SHARE = 0.25;
+export const MIN_CONFIRM_MS = 500;
+export class DeadlockError extends Error {
+    quietMs;
+    constructor(quietMs) {
+        super(`oxmutate: deadlocked for ${String(Math.round(quietMs))} ms: nothing left in this worker could resume the test`);
+        this.quietMs = quietMs;
+        this.name = 'DeadlockError';
+    }
+}
+export const isDeadlock = (e) => e instanceof DeadlockError;
+const { threadCpuUsage: threadCpu } = process;
+const threadCpuUsage = threadCpu?.bind(process);
+const { setInterval: realSetInterval, clearInterval: realClearInterval } = globalThis;
+const realNow = performance.now.bind(performance);
+const US_PER_MS = 1000;
+function resources() {
+    const counts = new Map();
+    for (const r of process.getActiveResourcesInfo())
+        counts.set(r, (counts.get(r) ?? 0) + 1);
+    return counts;
+}
+export const withinFloor = (now, floor) => [...now].every(([kind, n]) => n <= (floor.get(kind) ?? 0));
+export const quiet = (r) => r.selfShare < QUIET_SELF_SHARE && r.otherShare < QUIET_OTHER_SHARE && r.rpcInFlight === 0 && r.pendingTimers === 0 && r.withinFloor;
+let rpcInFlight = 0;
+let pendingTimers = 0;
+const live = new Map();
+const done = (id) => {
+    if (live.delete(id))
+        pendingTimers--;
+};
+const WRAPPED = Symbol.for('oxmutate.timers');
+const isWrapped = (fn) => typeof fn === 'function' && WRAPPED in fn;
+const mark = (fn) => Object.assign(fn, { [WRAPPED]: true });
+const clearing = (clear) => (handle) => {
+    if (handle !== undefined && handle !== null)
+        done(Number(handle));
+    clear(handle);
+};
+function pending(handle) {
+    live.set(Number(handle), true);
+    pendingTimers++;
+    return handle;
+}
+function oneShot(start, cb, args) {
+    const handle = start(() => {
+        done(Number(handle));
+        cb(...args);
+    });
+    return pending(handle);
+}
+function counted(p) {
+    pendingTimers++;
+    return p.finally(() => pendingTimers--);
+}
+function standIn(wrapper, original) {
+    const custom = Reflect.get(original, promisify.custom);
+    if (custom !== undefined)
+        Reflect.defineProperty(wrapper, promisify.custom, { value: custom });
+    return mark(wrapper);
+}
+export function wrapTimers(api) {
+    if (isWrapped(api.setTimeout))
+        return;
+    const { setTimeout: later, setImmediate: soon, setInterval: every, clearTimeout: unlater, clearImmediate: unsoon, clearInterval: unevery } = api;
+    const timeout = (cb, ms, ...args) => oneShot((fire) => later(fire, ms), cb, args);
+    const immediate = (cb, ...args) => oneShot((fire) => soon(fire), cb, args);
+    const interval = (cb, ms, ...args) => pending(every(cb, ms, ...args));
+    api.setTimeout = standIn(timeout, later);
+    api.setImmediate = standIn(immediate, soon);
+    api.setInterval = standIn(interval, every);
+    api.clearTimeout = clearing(unlater);
+    api.clearImmediate = clearing(unsoon);
+    api.clearInterval = clearing(unevery);
+}
+export function wrapPromiseTimers(api) {
+    if (isWrapped(api.setTimeout))
+        return;
+    const { setTimeout: later, setImmediate: soon } = api;
+    api.setTimeout = mark((...a) => counted(later(...a)));
+    api.setImmediate = mark((...a) => counted(soon(...a)));
+}
+export function trackTimers() {
+    wrapTimers(globalThis);
+    wrapTimers(timers);
+    wrapPromiseTimers(promiseTimers);
+    syncBuiltinESMExports();
+}
+export const pendingTimerCount = () => pendingTimers;
+export function trackRpc(state) {
+    const rpc = state?.rpc;
+    if (!rpc || rpc.__oxmutateTracked)
+        return;
+    state.rpc = new Proxy(rpc, {
+        get(target, key, receiver) {
+            if (key === '__oxmutateTracked')
+                return true;
+            const value = Reflect.get(target, key, receiver);
+            if (typeof value !== 'function' || typeof key !== 'string' || key.startsWith('$'))
+                return value;
+            const counted = (...args) => {
+                const result = Reflect.apply(value, target, args);
+                if (!(result instanceof Promise))
+                    return result;
+                rpcInFlight++;
+                return result.finally(() => rpcInFlight--);
+            };
+            return Object.defineProperties(counted, Object.getOwnPropertyDescriptors(value));
+        },
+    });
+}
+let floor;
+export const floorTaken = () => floor;
+export const rpcInFlightCount = () => rpcInFlight;
+export function takeFloor() {
+    floor ??= resources();
+}
+export function confirmStep(o) {
+    if (!o.quiet)
+        return { quietSince: undefined };
+    const since = o.quietSince ?? o.now - o.span;
+    const open = o.now - since;
+    return open >= o.confirmMs ? { quietSince: since, deadlockMs: open } : { quietSince: since };
+}
+export function watch() {
+    let armed;
+    let quietSince;
+    let self = threadCpuUsage?.();
+    let all = process.cpuUsage();
+    let at = realNow();
+    const timer = realSetInterval(() => {
+        const now = realNow();
+        const span = Math.max(1, now - at);
+        const selfDelta = threadCpuUsage?.(self);
+        const allDelta = process.cpuUsage(all);
+        self = threadCpuUsage?.();
+        all = process.cpuUsage();
+        at = now;
+        if (!armed || !selfDelta || !floor)
+            return;
+        const selfUs = selfDelta.user + selfDelta.system;
+        const reading = {
+            selfShare: selfUs / US_PER_MS / span,
+            otherShare: Math.max(0, allDelta.user + allDelta.system - selfUs) / US_PER_MS / span,
+            rpcInFlight,
+            pendingTimers,
+            withinFloor: withinFloor(resources(), floor),
+        };
+        if (env['OXMUTATE_DEBUG_QUIET'])
+            stderr.write(`quiet? ${JSON.stringify(reading)} res=${JSON.stringify([...resources()])} floor=${JSON.stringify([...floor])}\n`);
+        const next = confirmStep({ quietSince, quiet: quiet(reading), now, span, confirmMs: armed.confirmMs });
+        quietSince = next.quietSince;
+        if (next.deadlockMs !== undefined) {
+            const { reject } = armed;
+            armed = undefined;
+            reject(new DeadlockError(next.deadlockMs));
+        }
+    }, SAMPLE_MS);
+    timer.unref();
+    return {
+        async guard(fn, confirmMs) {
+            const pending = Promise.resolve().then(fn);
+            if (!threadCpuUsage)
+                return pending;
+            const deadlock = new Promise((_, reject) => {
+                quietSince = undefined;
+                armed = { reject, confirmMs: Math.max(MIN_CONFIRM_MS, confirmMs) };
+            });
+            try {
+                return await Promise.race([pending, deadlock]);
+            }
+            finally {
+                armed = undefined;
+                pending.catch(() => undefined);
+            }
+        },
+        stop() {
+            realClearInterval(timer);
+        },
+    };
+}

package/dist/reports.js

@@ -95,6 +95,7 @@ export function describe(m) {
 function corrections(s) {
     return [
         s.watchdogKills && `${String(s.watchdogKills)} runaway(s) stopped`,
+        s.deadlocks && `${String(s.deadlocks)} deadlock(s) called by their worker`,
         s.pollutionRestarts && `${String(s.pollutionRestarts)} polluted context(s) restarted (in ${String(s.canaryFiles)} file(s))`,
         s.flakyMutants && `${String(s.flakyMutants)} flaky verdict(s)`,
         s.survivorsOverturned && `${String(s.survivorsOverturned)} survivor(s) killed by a whole-file re-run`,

package/dist/runner.d.ts

@@ -50,6 +50,12 @@ export default class OxmutateRunner extends OxmutateRunner_base {
      * mutant is later re-run against the files that load its module, not the whole suite (Stryker
      * re-runs everything for each one).
      */
+    /**
+     * Before any test file is imported: count the timers it and the code under test will create, count
+     * Vitest's calls to its main thread, and take the resource floor a deadlock is measured against
+     * (quiescence.ts).
+     */
+    onBeforeCollect(paths: string[]): unknown;
     onCollectStart(file: AnyTask): unknown;
     onBeforeTryTask(test: AnyTask, options: {
         retry: number;

package/dist/runner.js

@@ -1,7 +1,9 @@
 import { appendFileSync, readFileSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
+import { availableParallelism, loadavg } from 'node:os';
 import path from 'node:path';
 import { BEAT_ENV, markTest, realNow, startHeartbeat } from './heartbeat.js';
+import { isDeadlock, takeFloor, trackRpc, trackTimers, watch } from './quiescence.js';
 import { resolveEsm } from './resolve.js';
 import { ACTIVE_MUTANT_ENV, FILE_KEY, NAMESPACE, cwd, env } from './runtime.js';
 const fromProject = async (specifier, dir = cwd()) => import(resolveEsm(specifier, dir));
@@ -51,6 +53,11 @@ if (mode === 'isolated' && env['OXMUTATE_HIT_LIMIT']) {
     ns.hitLimit = Number(env['OXMUTATE_HIT_LIMIT']);
 }
 const ranAway = () => ns.hitCount !== undefined && ns.hitLimit !== undefined && ns.hitCount > ns.hitLimit;
+const deadlocks = mode === 'dry' ? undefined : watch();
+let deadlocked = false;
+let tornDown = false;
+const confirmFor = (testId) => 2 * (plan.testMs?.[testId ?? ''] ?? 0) * Math.max(1, (loadavg()[0] ?? 0) / availableParallelism());
+const guarded = (testId, fn) => (deadlocks ? deadlocks.guard(fn, confirmFor(testId)) : Promise.resolve().then(fn));
 const PROTOTYPES = {
     Object: Object.prototype, Array: Array.prototype, String: String.prototype, Number: Number.prototype,
     Boolean: Boolean.prototype, Function: Function.prototype, Promise: Promise.prototype, Map: Map.prototype,
@@ -197,14 +204,19 @@ async function runCollected(file, runnable) {
                 const cleanups = await beforeEach(t, t.context);
                 ran++;
                 try {
-                    await fn();
+                    await guarded(t.id, fn);
                 }
                 catch (e) {
+                    if (isDeadlock(e))
+                        deadlocked = true;
                     failed.push(t.id);
                     note(t, e);
+                    if (isDeadlock(e))
+                        return;
                 }
                 finally {
-                    await afterEach(t, t.context, cleanups);
+                    if (!deadlocked)
+                        await afterEach(t, t.context, cleanups);
                 }
             }
         }
@@ -229,6 +241,14 @@ function fullName(t) {
     return parts.join(' > ');
 }
 export default class OxmutateRunner extends Base {
+    onBeforeCollect(paths) {
+        if (deadlocks) {
+            trackTimers();
+            trackRpc(this.workerState);
+            takeFloor();
+        }
+        return super.onBeforeCollect?.(paths);
+    }
     onCollectStart(file) {
         if (mode === 'dry')
             ns.currentTestId = `${FILE_KEY}${file.filepath ?? file.file?.filepath ?? ''}`;
@@ -248,15 +268,22 @@ export default class OxmutateRunner extends Base {
                 return;
             markTest(true);
             try {
-                await fn();
+                await guarded(test.id, fn);
                 if (mode === 'dry')
                     await probe(test, fn);
             }
+            catch (e) {
+                if (isDeadlock(e))
+                    deadlocked = true;
+                throw e;
+            }
             finally {
                 markTest(false);
             }
             return;
         }
+        if (tornDown)
+            return;
         let current = test;
         let run = fn;
         let context = test.context;
@@ -267,7 +294,7 @@ export default class OxmutateRunner extends Base {
         let cleanups = [];
         let attempt = 0;
         const teardown = async () => {
-            await afterEach(current, context, cleanups);
+            await guarded(current.id, () => afterEach(current, context, cleanups));
             cleanups = [];
         };
         const setup = async () => {
@@ -280,7 +307,7 @@ export default class OxmutateRunner extends Base {
                 context = copy.context;
             }
             invoked = true;
-            cleanups = await beforeEach(current, context);
+            cleanups = await guarded(current.id, () => beforeEach(current, context));
             await this.retryReset(test, ++attempt);
         };
         const fresh = async () => {
@@ -288,62 +315,96 @@ export default class OxmutateRunner extends Base {
             await setup();
         };
         let unchecked = [];
+        const pollutedBy = (e) => {
+            polluted = true;
+            canaryEvery = 1;
+            emit({ type: 'polluted', id: unchecked[0], suspects: unchecked.slice(1), test: test.id, file: test.file?.filepath, error: e instanceof Error ? e.message.slice(0, POLLUTION_ERROR_CHARS) : String(e) });
+            return false;
+        };
         const canary = async () => {
             if (!unchecked.length)
                 return true;
-            await fresh();
             try {
-                await run();
+                await fresh();
+            }
+            catch (e) {
+                if (!isDeadlock(e))
+                    throw e;
+                return pollutedBy(e);
+            }
+            try {
+                await guarded(test.id, run);
                 unchecked = [];
                 canaryEvery = Math.min(MAX_CANARY_EVERY, canaryEvery * 2);
                 return true;
             }
             catch (e) {
-                polluted = true;
-                canaryEvery = 1;
-                emit({ type: 'polluted', id: unchecked[0], suspects: unchecked.slice(1), test: test.id, file: test.file?.filepath, error: e instanceof Error ? e.message.slice(0, POLLUTION_ERROR_CHARS) : String(e) });
-                return false;
+                return pollutedBy(e);
             }
         };
         const runArmed = async (id) => {
-            await teardown();
+            try {
+                await teardown();
+            }
+            catch (e) {
+                if (!isDeadlock(e))
+                    throw e;
+                pollutedBy(e);
+                return { status: 'Polluted', ms: 0 };
+            }
             const t0 = performance.now();
             ns.activeMutant = id;
             ns.hitCount = 0;
             ns.hitLimit = plan.hitLimits[id] ?? Number.MAX_SAFE_INTEGER;
             let status = 'Survived';
+            let deadlock = false;
             try {
                 await setup();
-                await run();
+                await guarded(current.id, run);
             }
             catch (e) {
-                status = isHitLimit(e) ? 'Timeout' : 'Killed';
+                deadlock = isDeadlock(e);
+                status = isHitLimit(e) || deadlock ? 'Timeout' : 'Killed';
             }
             finally {
                 ns.activeMutant = undefined;
                 ns.hitCount = undefined;
                 ns.hitLimit = undefined;
             }
-            return { status, ms: performance.now() - t0 };
+            return { status, ms: performance.now() - t0, ...(deadlock && { deadlock: true }) };
         };
         for (const id of ids) {
             if (done.has(id))
                 continue;
             if (progressPath)
                 writeFileSync(progressPath, `${id} ${String(realNow())}\n`);
-            let { status, ms } = await runArmed(id);
+            let { status, ms, deadlock } = await runArmed(id);
+            if (status === 'Polluted')
+                break;
             if (status !== 'Survived' && unchecked.length > 0) {
                 if (!(await canary()))
                     break;
-                ({ status, ms } = await runArmed(id));
+                ({ status, ms, deadlock } = await runArmed(id));
+                if (status === 'Polluted')
+                    break;
             }
             if (status !== 'Survived')
                 done.add(id);
-            emit({ type: 'mutant', id, test: test.id, status, ms, ...(spec ? { spec: true } : {}) });
+            emit({ type: 'mutant', id, test: test.id, status, ms, ...(spec ? { spec: true } : {}), ...(deadlock && { deadlock: true }) });
             unchecked.push(id);
+            if (deadlock) {
+                pollutedBy(new Error('torn down: a deadlocked run is still pending in this worker'));
+                tornDown = true;
+                break;
+            }
             if (unchecked.length >= canaryEvery && !(await canary()))
                 break;
         }
+        if (tornDown) {
+            if (progressPath)
+                writeFileSync(progressPath, '');
+            return;
+        }
         if (!polluted)
             await canary();
         if (progressPath && ids.length)
@@ -407,11 +468,12 @@ export default class OxmutateRunner extends Base {
             ns.activeMutant = armed;
             ns.hitCount = armed ? 0 : undefined;
             ns.hitLimit = armed ? (staticLimits[armed] ?? Number.MAX_SAFE_INTEGER) : undefined;
+            deadlocked = false;
             try {
                 vi.resetModules();
                 const [file] = await collectTests([filepath], this);
                 const result = file ? await runCollected(file, runnable) : { failed: [filepath], ran: 0 };
-                return { ...result, timeout: ranAway() };
+                return { ...result, timeout: ranAway() || deadlocked, ...(deadlocked ? { deadlock: true } : {}) };
             }
             finally {
                 ns.activeMutant = undefined;
@@ -431,6 +493,8 @@ export default class OxmutateRunner extends Base {
             if (progressPath)
                 writeFileSync(progressPath, `${id} ${String(realNow())}\n`);
             held.push({ id, verdict: await evaluate(id) });
+            if (held.at(-1)?.verdict.deadlock)
+                return back('torn down: a deadlocked run is still pending in this worker');
             const left = snapshotDiff(before, snapshot());
             if (left.length)
                 return back('the mutant left a trace', left);
@@ -444,7 +508,7 @@ export default class OxmutateRunner extends Base {
             if (after.length)
                 return back('the unarmed re-collection left a trace', after);
             for (const { id: done, verdict } of held)
-                emit({ type: 'isolated', id: done, killed: verdict.failed.length > 0 && !verdict.timeout, failed: verdict.failed, ran: verdict.ran, ...(verdict.timeout && { timeout: true }) });
+                emit({ type: 'isolated', id: done, killed: verdict.failed.length > 0 && !verdict.timeout, failed: verdict.failed, ran: verdict.ran, ...(verdict.timeout && { timeout: true }), ...(verdict.deadlock && { deadlock: true }) });
             held = [];
             every = Math.min(STATIC_CANARY_MAX, every * 2);
         }
@@ -528,8 +592,8 @@ export default class OxmutateRunner extends Base {
                 if (f.result?.state === 'fail' && !failed.length)
                     failed.push(f.id);
             }
-            const timeout = ranAway();
-            emit({ type: 'isolated', id: env[ACTIVE_MUTANT_ENV] ?? ns.activeMutant, killed: failed.length > 0 && !timeout, failed, ran, ...(timeout && { timeout }) });
+            const timeout = ranAway() || deadlocked;
+            emit({ type: 'isolated', id: env[ACTIVE_MUTANT_ENV] ?? ns.activeMutant, killed: failed.length > 0 && !timeout, failed, ran, ...(timeout && { timeout }), ...(deadlocked && { deadlock: true }) });
         }
         return super.onAfterRunFiles?.(files);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxmutate",
-  "version": "1.2.5",
+  "version": "1.3.0",
   "description": "Mutation testing for JavaScript and TypeScript on the oxc engine, run warm inside the project's own Vitest, with CI lanes, SARIF and an agent surface. No dependency outside the burgee family. A Stryker migration path.",
   "license": "MIT",
   "repository": {