oxmutate 1.0.3 → 1.2.0

package/dist/heartbeat.js

@@ -0,0 +1,111 @@
+/**
+ * The watchdog's evidence for the difference between a mutant that loops and one that hangs
+ * (.sdlc/intents/oxmutate/stall.qnt, D-20261101-idle-stall-is-timeout).
+ *
+ * Two readings, both taken when a run passes its budget:
+ *
+ * - **The beat.** The test worker writes the time to its server's beat file every HEARTBEAT_MS
+ *   from a real interval timer. The beat keeps coming only while the worker's event loop turns. A
+ *   synchronous loop stops it, and so does a microtask loop.
+ * - **The CPU.** The server reports its process's CPU time (every thread, the worker included)
+ *   every CPU_SAMPLE_MS. Over the last CPU_WINDOW_MS, a loop burns about a core.
+ *
+ * A run whose worker is inside a test body, with a fresh beat and under IDLE_CPU of a core, is
+ * **idle**: the test waits on something the mutant never lets happen (a prompt awaiting a
+ * keypress). Anything else is **busy**, including a worker still collecting its file: on a loaded
+ * machine a short budget can run out while modules load, at low CPU, and that is a slow machine. On a caique
+ * subset 18 of 19 stops read 0–2% CPU with a live beat, and the one loop read 72%
+ * (sc8-profile.md). An idle stop is a Timeout as it stands, the way Stryker scores it. A busy stop
+ * may be a slow test on a loaded machine, so it keeps its re-run at 3x.
+ *
+ * The beat file is the server's, named by its pid and set in its environment when it starts, so
+ * every worker it ever runs inherits it: a path set per unit could reach a worker that started
+ * under an earlier unit, and on caique two stops read a beat that never came.
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+/** How often the worker writes its beat. */
+export const HEARTBEAT_MS = 250;
+/** A beat older than this means the worker's event loop is not turning: a loop, not a wait. */
+export const STALE_MS = 1000;
+/** How often a server reports its CPU time. */
+export const CPU_SAMPLE_MS = 250;
+/** The window a stop's CPU share is measured over. */
+export const CPU_WINDOW_MS = 1000;
+/** The shortest span of samples a CPU share is read from; less, and the stop counts as busy. */
+export const MIN_CPU_SPAN_MS = 500;
+/** Under this share of one core, with a fresh beat, a stopped run is idle. Measured: idle 0–2%, a loop 72–108%. */
+export const IDLE_CPU = 0.25;
+/** The environment variable that hands a server's beat file to its test workers. */
+export const BEAT_ENV = 'OXMUTATE_BEAT';
+/** A server's beat file, in the run's work directory. */
+export const beatFile = (workDir, pid) => path.join(workDir, `beat-${String(pid)}`);
+// Captured when this module is evaluated, before any test file can install fake timers: a faked
+// clock would write a frozen time, and the watchdog would read a live worker as a stale one.
+const { setInterval: realSetInterval, clearInterval: realClearInterval } = globalThis;
+const realNow = Date.now.bind(Date);
+/** The beat this thread runs: one at a time, whatever re-evaluates this module. */
+// Stryker disable next-line StringLiteral: any key names one registry symbol on every evaluation of this module, which is all the key is for
+const BEAT_KEY = Symbol.for('oxmutate.heartbeat');
+/** Whether a test body is running in this worker (the runner marks it); the beat carries it. */
+let inTest = false;
+/** Mark a test body as running, or done. Only a wait inside a test body can be an idle stall. */
+export function markTest(running) {
+    inTest = running;
+}
+/** Start this worker's beat into `file`. Does nothing when no beat file is set. */
+export function startHeartbeat(file) {
+    if (!file)
+        return;
+    const holder = globalThis;
+    realClearInterval(holder[BEAT_KEY]);
+    /** One beat; false once the run's directory is gone: the run is over, and nothing reads the beat. */
+    const beat = () => {
+        try {
+            writeFileSync(file, inTest ? `${String(realNow())} test` : String(realNow()));
+        }
+        catch {
+            return false;
+        }
+        return true;
+    };
+    beat();
+    holder[BEAT_KEY] = realSetInterval(() => {
+        if (!beat())
+            realClearInterval(holder[BEAT_KEY]);
+    }, HEARTBEAT_MS);
+    // Stryker disable next-line CallExpression: unref only lets a process exit while its beat runs; Vitest ends its workers regardless, so no verdict depends on it
+    holder[BEAT_KEY].unref();
+}
+/** The last beat of this server's workers. */
+export function readBeat(file, now = Date.now()) {
+    let text;
+    try {
+        text = String(readFileSync(file));
+    }
+    catch {
+        return { age: Number.POSITIVE_INFINITY, inTest: false };
+    }
+    const [stamp, where] = text.split(' ');
+    const at = Number(stamp);
+    return { age: Number.isFinite(at) && at > 0 ? now - at : Number.POSITIVE_INFINITY, inTest: where === 'test' };
+}
+const US_PER_MS = 1000;
+/**
+ * The share of one core a server used over the last CPU_WINDOW_MS before `now`, from its samples
+ * (oldest first). Undefined when the samples span less than MIN_CPU_SPAN_MS of that window.
+ */
+export function cpuShare(samples, now) {
+    const recent = samples.filter((s) => s.at >= now - CPU_WINDOW_MS && s.at <= now);
+    const first = recent[0];
+    const last = recent.at(-1);
+    // Stryker disable next-line LogicalOperator: the first and the last sample are both there or both missing, so `&&` reads the same
+    if (!first || !last || last.at - first.at < MIN_CPU_SPAN_MS)
+        return undefined;
+    return (last.us - first.us) / US_PER_MS / (last.at - first.at);
+}
+/** A stopped run is idle when its worker waits inside a test body, its event loop turning, and its server burns almost no CPU. */
+export function classifyStall(o) {
+    return o.beat.inTest && o.beat.age < STALE_MS && (o.cpuShare ?? IDLE_CPU) < IDLE_CPU ? 'idle' : 'busy';
+}
+//# sourceMappingURL=heartbeat.js.map

package/dist/lanes.js

@@ -49,6 +49,7 @@ export function shardOf(id, count) {
     // Ids are hex (`native/src/stable_id.rs`), so a code point is a code unit and the shards are
     // the ones `charCodeAt` gave.
     for (let i = 0; i < id.length; i++) {
+        // Stryker disable next-line NumericLiteral: `i < id.length`, so codePointAt never returns undefined here
         h ^= id.codePointAt(i) ?? 0;
         h = Math.imul(h, FNV_PRIME) >>> 0;
     }

package/dist/progress.js

@@ -5,6 +5,7 @@
  * shows the run moving without a carriage-return mess. Off unless a progress reporter is named.
  */
 const REPORTERS = new Set(['progress', 'progress-append-only', 'ci', 'dots']);
+// Stryker disable next-line NumericLiteral: a repaint interval; no test can see 1,000 ms against 1,001
 const TTY_EVERY_MS = 1000;
 const APPEND_EVERY_MS = 10_000;
 const MS_PER_S = 1000;

package/dist/reports.js

@@ -142,7 +142,7 @@ export function textSummary(r, opts = {}) {
         `oxmutate ${VERSION}: ${String(r.mutants.length)} mutants in ${String(s.files)} files, ${(s.wallMs / MS_PER_S).toFixed(1)} s`,
         `  mutation score ${r.score.mutationScore.toFixed(2)}% (covered ${r.score.covered.toFixed(2)}%)`,
         `  killed ${String(count('Killed'))} · timeout ${String(count('Timeout'))} · survived ${String(count('Survived'))} · no coverage ${String(count('NoCoverage'))} · ignored ${String(count('Ignored'))} · errors ${String(count('RuntimeError') + count('CompileError'))}`,
-        `  instrument ${s.instrumentMs.toFixed(0)} ms · dry run ${(s.dryRunMs / MS_PER_S).toFixed(1)} s · mutants ${(s.mutationMs / MS_PER_S).toFixed(1)} s · isolated ${(s.isolatedMs / MS_PER_S).toFixed(1)} s`,
+        `  instrument ${s.instrumentMs.toFixed(0)} ms · dry run ${(s.dryRunMs / MS_PER_S).toFixed(1)} s · mutants ${(s.mutationMs / MS_PER_S).toFixed(1)} s · static ${(s.staticMs / MS_PER_S).toFixed(1)} s · isolated ${(s.isolatedMs / MS_PER_S).toFixed(1)} s`,
     ];
     const corrected = corrections(s);
     if (corrected.length)

package/dist/runner.d.ts

@@ -13,6 +13,8 @@ type AnyTask = {
         duration?: number;
     };
     tasks?: AnyTask[] | undefined;
+    mode?: string;
+    context?: unknown;
 };
 /** The family's refusal shape for a missing optional peer (as `controlroom/ink`'s): a code and a fix. */
 export declare class PeerMissingError extends Error {
@@ -21,6 +23,9 @@ export declare class PeerMissingError extends Error {
     constructor(cause: unknown);
 }
 declare const OxmutateRunner_base: new (config: unknown) => {
+    onBeforeCollect?(paths: string[]): unknown;
+    importFile?(filepath: string, source: string): unknown;
+    onBeforeRunSuite?(suite: AnyTask): unknown;
     onCollectStart?(file: unknown): unknown;
     onBeforeTryTask?(test: AnyTask, options: {
         retry: number;
@@ -42,6 +47,22 @@ export default class OxmutateRunner extends OxmutateRunner_base {
     runTask(test: AnyTask & {
         context?: unknown;
     }): Promise<void>;
+    /**
+     * The baseline is taken as the test file itself is imported (`source: 'collect'`), after setup
+     * files: those run before every collection, re-collections included, and write the same values
+     * each time (the family's colour setup sets TERM, COLORTERM and NO_COLOR), so they are not leaks.
+     */
+    importFile(filepath: string, source: string): unknown;
+    onBeforeRunSuite(suite: AnyTask): Promise<unknown>;
+    /**
+     * `static` mode (.sdlc/intents/oxmutate/staticwarm.qnt). Re-evaluating the project's modules in
+     * this worker costs ~0.5 ms where a fresh worker per (mutant, file) cost ~80 ms (burgee/paratext,
+     * 2026-10-30). What a registry reset leaves behind is guarded three ways: the file's own unarmed
+     * collection must leave globalThis, process.env and the built-in prototypes as they were; so must
+     * each mutant; and an unarmed re-collection after each mutant must pass. Anything else hands the
+     * rest of the batch back to the fresh-worker path.
+     */
+    private decideStatic;
     /** Reset per-try state (snapshot counters, assertion counts) the way Vitest does for a retry. */
     private retryReset;
     onAfterRunFiles(files: AnyTask[]): unknown;

package/dist/runner.js

@@ -13,6 +13,11 @@
  *   failure there means an earlier mutant polluted shared state (the canary).
  * - `isolated`: one mutant was armed before import (static mutants and canary re-runs). Run
  *   normally; any failed test kills it.
+ * - `static`: a batch of static mutants decided in this live worker (staticwarm.qnt). Before the file
+ *   runs, each mutant is armed, the module registry is reset and the file is collected again, so
+ *   its tests close over modules evaluated under the mutant; they run with their hooks, then an
+ *   unarmed re-collection must pass. A file whose own collection touches globals, or a mutant that
+ *   leaves a trace, sends the rest of the batch back to the fresh-worker path (`static-fallback`).
  *
  * Before each mutant the runner writes a progress line synchronously, so the coordinator can
  * attribute and kill a worker stuck in a synchronous loop that the hit counter cannot break.
@@ -20,6 +25,7 @@
 import { appendFileSync, readFileSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
+import { BEAT_ENV, markTest, startHeartbeat } from './heartbeat.js';
 import { resolveEsm } from './resolve.js';
 import { ACTIVE_MUTANT_ENV, FILE_KEY, NAMESPACE, cwd, env } from './runtime.js';
 /**
@@ -60,6 +66,7 @@ const { Base, statics } = await loadBase();
 const mode = env['OXMUTATE_MODE'] ?? 'dry';
 const resultsPath = env['OXMUTATE_RESULTS'];
 const progressPath = env['OXMUTATE_PROGRESS'];
+startHeartbeat(env[BEAT_ENV]); // the watchdog tells a wait from a loop by it (heartbeat.ts)
 const ns = (globalThis[NAMESPACE] ??= {});
 ns.mutantCoverage ??= { static: {}, perTest: {} };
 const plan = mode === 'mutant' && env['OXMUTATE_PLAN'] ? JSON.parse(readFileSync(env['OXMUTATE_PLAN'], 'utf8')) : { tests: {}, hitLimits: {}, skip: [] };
@@ -69,8 +76,57 @@ const specTests = new Set(plan.specTests ?? []);
 const decidedBySpec = new Set();
 /** `isolated`: when set, only these tests run (the mutant's covering tests); the rest pass untouched. */
 const only = mode === 'isolated' && env['OXMUTATE_ONLY_TESTS'] ? new Set(JSON.parse(env['OXMUTATE_ONLY_TESTS'])) : undefined;
+/** `static`: the static mutants this file run decides in the live worker. */
+const staticIds = mode === 'static' && env['OXMUTATE_STATIC'] ? JSON.parse(env['OXMUTATE_STATIC']) : [];
+/** `static`: each mutant's hit-count limit. */
+const staticLimits = mode === 'static' && env['OXMUTATE_HIT_LIMITS'] ? JSON.parse(env['OXMUTATE_HIT_LIMITS']) : {};
+// `isolated`: the mutant is armed from process start, so its hit counter is too. A loop it causes
+// stops at the limit, as in warm runs, instead of holding the worker until the watchdog's budget:
+// on oxmutate's own suite 17 runaways left the isolated phase idle 140 of 186 s (2026-10-30).
+if (mode === 'isolated' && env['OXMUTATE_HIT_LIMIT']) {
+    ns.hitCount = 0;
+    ns.hitLimit = Number(env['OXMUTATE_HIT_LIMIT']);
+}
+/** Did the armed mutant's switch pass its limit, i.e. was this run stopped as a runaway? */
+const ranAway = () => ns.hitCount !== undefined && ns.hitLimit !== undefined && ns.hitCount > ns.hitLimit;
+// ── `static` mode: what a registry reset does not reset ─────────────────────────────────────────
+/** Built-ins a module may patch in place; their own methods are compared by identity. */
+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,
+    Set: Set.prototype, RegExp: RegExp.prototype, Date: Date.prototype, Error: Error.prototype,
+};
+/** Keys Vitest and oxmutate own: they change by design while a file runs. */
+const OWN_GLOBAL = /^(__vitest|__oxmutate__$|__VITEST|__vite)/;
+/** globalThis, process.env and the built-in prototypes, as a map a later look can be compared with. */
+function snapshot() {
+    const out = new Map();
+    const g = globalThis;
+    for (const k of Object.getOwnPropertyNames(g)) {
+        if (OWN_GLOBAL.test(k))
+            continue;
+        const d = Object.getOwnPropertyDescriptor(g, k);
+        out.set(`g:${k}`, d && 'value' in d ? d.value : d?.get);
+    }
+    for (const [k, v] of Object.entries(env))
+        out.set(`env:${k}`, v);
+    for (const [name, proto] of Object.entries(PROTOTYPES)) {
+        for (const k of Object.getOwnPropertyNames(proto))
+            out.set(`proto:${name}.${k}`, Object.getOwnPropertyDescriptor(proto, k)?.value);
+    }
+    return out;
+}
+/** How many differing keys a `static-fallback` record names. */
+const DIFF_KEYS = 8;
+/** The keys whose presence or value differs between two snapshots (the first few, for a report). */
+const snapshotDiff = (a, b) => [...new Set([...a.keys(), ...b.keys()])].filter((k) => !(a.has(k) && b.has(k) && Object.is(a.get(k), b.get(k)))).slice(0, DIFF_KEYS);
+const sameSnapshot = (a, b) => snapshotDiff(a, b).length === 0;
+/** The state before this worker evaluated the test file: the baseline every later look compares with. */
+let pristine;
 /** Set when a mutant left state behind; the rest of this context runs no mutants. */
 let polluted = false;
+/** `static` mode: the most mutants decided between two unarmed re-collections (staticwarm.qnt `grouped`). */
+const STATIC_CANARY_MAX = 4;
 /** Mutants between canaries; doubles while the canary stays clean, back to 1 when it fails. */
 let canaryEvery = 1;
 const MAX_CANARY_EVERY = 8;
@@ -81,10 +137,16 @@ function emit(record) {
     if (resultsPath)
         appendFileSync(resultsPath, `${JSON.stringify(record)}\n`);
 }
+// The suites whose hooks wrap `test`, outermost first. Vitest 5 leaves a top-level `describe`'s
+// `suite` unset and keeps file-level hooks on `test.file`, so the walk adds the file itself: without
+// it a file-level `beforeEach` reset never re-ran between mutants and every canary read as pollution.
 function chain(test) {
     const suites = [];
     for (let s = test.suite; s; s = s.suite)
         suites.unshift(s);
+    const file = test.file;
+    if (file && suites[0] !== file)
+        suites.unshift(file);
     return suites;
 }
 async function beforeEach(test, context) {
@@ -107,6 +169,61 @@ async function afterEach(test, context, cleanups) {
         await cleanup();
 }
 const isHitLimit = (e) => e instanceof Error && /Hit count limit/.test(e.message);
+/**
+ * Runs a file collected outside Vitest's own run (`static` mode): each suite's beforeAll/afterAll,
+ * each test with its beforeEach/afterEach chain, stopping at the first failure, which is all a
+ * mutant's verdict needs.
+ */
+async function runCollected(file, runnable) {
+    const failed = [];
+    let error;
+    const note = (t, e) => {
+        error ??= `${fullName(t)}: ${e instanceof Error ? e.message : String(e)}`.slice(0, POLLUTION_ERROR_CHARS);
+    };
+    let ran = 0;
+    const runSuite = async (suite) => {
+        const hooks = statics.getSuiteHooks(suite);
+        for (const hook of hooks.beforeAll)
+            await hook(suite);
+        try {
+            for (const t of suite.tasks ?? []) {
+                if (failed.length)
+                    return;
+                if (t.type === 'suite') {
+                    await runSuite(t);
+                    continue;
+                }
+                const fn = runnable.has(t.id) ? statics.getTestFn(t) : undefined;
+                if (!fn)
+                    continue;
+                const cleanups = await beforeEach(t, t.context);
+                ran++;
+                try {
+                    await fn();
+                }
+                catch (e) {
+                    failed.push(t.id);
+                    note(t, e);
+                }
+                finally {
+                    await afterEach(t, t.context, cleanups);
+                }
+            }
+        }
+        finally {
+            for (const hook of hooks.afterAll)
+                await hook(suite);
+        }
+    };
+    try {
+        await runSuite(file);
+    }
+    catch (e) {
+        failed.push(file.id); // a hook threw: the file failed under the mutant, as Stryker scores it
+        note(file, e);
+    }
+    return { failed, ran, ...(error !== undefined && { error }) };
+}
 function fullName(t) {
     const parts = [t.name];
     for (let s = t.suite; s && s.type === 'suite' && s.name; s = s.suite)
@@ -136,7 +253,14 @@ export default class OxmutateRunner extends Base {
         if (mode !== 'mutant') {
             if (only && !only.has(test.id))
                 return;
-            await fn();
+            // Only a wait inside a test body can be an idle stall; collection at low CPU is a slow machine.
+            markTest(true);
+            try {
+                await fn();
+            }
+            finally {
+                markTest(false);
+            }
             return;
         }
         const context = test.context;
@@ -147,11 +271,18 @@ export default class OxmutateRunner extends Base {
         const ids = polluted ? [] : (plan.tests[test.id] ?? []).filter((id) => !done.has(id));
         let cleanups = [];
         let attempt = 0;
-        const fresh = async () => {
+        const teardown = async () => {
             await afterEach(test, context, cleanups);
+            cleanups = [];
+        };
+        const setup = async () => {
             cleanups = await beforeEach(test, context);
             await this.retryReset(test, ++attempt);
         };
+        const fresh = async () => {
+            await teardown();
+            await setup();
+        };
         // Mutants run since the last clean canary. The first of them started from a clean state, so its
         // verdict stands whatever the next canary says; the rest are suspects if it fails.
         let unchecked = [];
@@ -172,19 +303,20 @@ export default class OxmutateRunner extends Base {
                 return false;
             }
         };
-        for (const id of ids) {
-            if (done.has(id))
-                continue;
-            if (attempt > 0)
-                await fresh();
-            if (progressPath)
-                writeFileSync(progressPath, `${id} ${String(Date.now())}\n`);
+        // The mutant is armed through the test's own `beforeEach`, as Stryker arms it: the dry run credits
+        // code a hook runs to the test, so a mutant in a fixture builder or a seed is planned here, and with
+        // the hooks run unarmed it always survived, to be killed later by an isolated run that costs a
+        // fresh process (58 of 400 on a Mongo-backed suite, 2026-10-29). The previous run's `afterEach`
+        // runs first, unarmed: its cleanup belongs to that run.
+        const runArmed = async (id) => {
+            await teardown();
             const t0 = performance.now();
             ns.activeMutant = id;
             ns.hitCount = 0;
             ns.hitLimit = plan.hitLimits[id] ?? Number.MAX_SAFE_INTEGER;
             let status = 'Survived';
             try {
+                await setup();
                 await fn();
             }
             catch (e) {
@@ -195,9 +327,27 @@ export default class OxmutateRunner extends Base {
                 ns.hitCount = undefined;
                 ns.hitLimit = undefined;
             }
+            return { status, ms: performance.now() - t0 };
+        };
+        for (const id of ids) {
+            if (done.has(id))
+                continue;
+            if (progressPath)
+                writeFileSync(progressPath, `${id} ${String(Date.now())}\n`);
+            let { status, ms } = await runArmed(id);
+            // A kill that follows unchecked runs may be one of their leftovers, which this run's own cleanup
+            // (a `finally`) then wipes, so the batch canary would pass and vouch for a wrong kill. Survivors
+            // are confirmed in isolation later; kills are checked here: a failing canary is pollution as
+            // usual (this verdict goes back with the unit), a passing one leaves the state clean to decide
+            // the mutant again from (.sdlc/intents/oxmutate/canary.qnt).
+            if (status !== 'Survived' && unchecked.length > 0) {
+                if (!(await canary()))
+                    break;
+                ({ status, ms } = await runArmed(id));
+            }
             if (status !== 'Survived')
                 done.add(id);
-            emit({ type: 'mutant', id, test: test.id, status, ms: performance.now() - t0, ...(spec ? { spec: true } : {}) });
+            emit({ type: 'mutant', id, test: test.id, status, ms, ...(spec ? { spec: true } : {}) });
             unchecked.push(id);
             // The canary: the same test, unmutated, must still pass. If it fails, a mutant left state
             // behind (a cache, a registry, a fixture) that would decide the next verdicts. Run after every
@@ -220,6 +370,114 @@ export default class OxmutateRunner extends Base {
                 await cleanup();
         }
     }
+    /**
+     * The baseline is taken as the test file itself is imported (`source: 'collect'`), after setup
+     * files: those run before every collection, re-collections included, and write the same values
+     * each time (the family's colour setup sets TERM, COLORTERM and NO_COLOR), so they are not leaks.
+     */
+    importFile(filepath, source) {
+        if (mode === 'static' && source === 'collect' && !pristine)
+            pristine = snapshot();
+        return super.importFile?.(filepath, source);
+    }
+    async onBeforeRunSuite(suite) {
+        if (mode === 'static' && suite.filepath && staticIds.length)
+            await this.decideStatic(suite);
+        return super.onBeforeRunSuite?.(suite);
+    }
+    /**
+     * `static` mode (.sdlc/intents/oxmutate/staticwarm.qnt). Re-evaluating the project's modules in
+     * this worker costs ~0.5 ms where a fresh worker per (mutant, file) cost ~80 ms (burgee/paratext,
+     * 2026-10-30). What a registry reset leaves behind is guarded three ways: the file's own unarmed
+     * collection must leave globalThis, process.env and the built-in prototypes as they were; so must
+     * each mutant; and an unarmed re-collection after each mutant must pass. Anything else hands the
+     * rest of the batch back to the fresh-worker path.
+     */
+    async decideStatic(suite) {
+        const filepath = suite.filepath;
+        // The tests this run will execute, after Vitest's own filters (a name pattern, `.only`, `.skip`):
+        // a re-collected file has the same test ids, and runs exactly these.
+        const runnable = new Set();
+        const visit = (t) => {
+            if (t.type === 'test' && t.mode === 'run')
+                runnable.add(t.id);
+            for (const c of t.tasks ?? [])
+                visit(c);
+        };
+        visit(suite);
+        const rest = [...staticIds];
+        const fallback = (reason, keys = []) => {
+            emit({ type: 'static-fallback', ids: rest.splice(0), reason, keys });
+        };
+        const before = pristine;
+        if (!before)
+            return fallback('no baseline');
+        const atCollect = snapshotDiff(before, snapshot());
+        if (atCollect.length)
+            return fallback('the file changed globals while it was collected', atCollect);
+        const vitest = (await fromProject('vitest'));
+        // `collectTests` is exported for Vitest's browser runner from an internal subpath: if a Vitest
+        // moves or drops it, the import fails and the fresh-worker path decides, as on Vitest 4.
+        const browser = (await fromProject('vitest/internal/browser').catch(() => ({})));
+        const { collectTests } = browser;
+        const { vi } = vitest;
+        if (!collectTests || !vi)
+            return fallback('this Vitest has no public collect'); // Vitest 4: the fresh path decides
+        const evaluate = async (armed) => {
+            ns.activeMutant = armed;
+            ns.hitCount = armed ? 0 : undefined;
+            ns.hitLimit = armed ? (staticLimits[armed] ?? Number.MAX_SAFE_INTEGER) : undefined;
+            try {
+                vi.resetModules();
+                const [file] = await collectTests([filepath], this);
+                const result = file ? await runCollected(file, runnable) : { failed: [filepath], ran: 0 };
+                return { ...result, timeout: ranAway() };
+            }
+            finally {
+                ns.activeMutant = undefined;
+                ns.hitCount = undefined;
+                ns.hitLimit = undefined;
+            }
+        };
+        // Verdicts since the last clean unarmed re-collection are held, not emitted: the re-collection runs
+        // after the first mutant, then after every 2, then every STATIC_CANARY_MAX while it stays clean, and
+        // one that fails sends every held mutant back with the rest. Each mutant's own snapshot diff still
+        // runs at once. The re-collection runs the file's tests unarmed, and after every mutant it was half
+        // of the live static phase, 6,713 s of compat-oracle's 11,193 s weekly run (sc8-profile.md,
+        // staticwarm.qnt `grouped`).
+        let held = [];
+        let every = 1;
+        const back = (reason, keys = []) => {
+            rest.unshift(...held.map((h) => h.id));
+            held = [];
+            fallback(reason, keys);
+        };
+        while (rest.length) {
+            const id = rest.shift();
+            if (progressPath)
+                writeFileSync(progressPath, `${id} ${String(Date.now())}\n`);
+            held.push({ id, verdict: await evaluate(id) });
+            const left = snapshotDiff(before, snapshot());
+            if (left.length)
+                return back('the mutant left a trace', left);
+            if (held.length < every && rest.length)
+                continue;
+            const unarmed = await evaluate(undefined);
+            emit({ type: 'recollection' });
+            if (unarmed.failed.length > 0)
+                return back('the unarmed re-collection failed', unarmed.error ? [unarmed.error] : []);
+            const after = snapshotDiff(before, snapshot());
+            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 }) });
+            held = [];
+            every = Math.min(STATIC_CANARY_MAX, every * 2);
+        }
+        if (progressPath)
+            writeFileSync(progressPath, '');
+        vi.resetModules();
+    }
     /** Reset per-try state (snapshot counters, assertion counts) the way Vitest does for a retry. */
     async retryReset(test, attempt) {
         await super.onBeforeTryTask?.(test, { retry: attempt, repeats: 0 });
@@ -262,7 +520,8 @@ export default class OxmutateRunner extends Base {
                 if (f.result?.state === 'fail' && !failed.length)
                     failed.push(f.id);
             }
-            emit({ type: 'isolated', id: env[ACTIVE_MUTANT_ENV] ?? ns.activeMutant, killed: failed.length > 0, failed, ran });
+            const timeout = ranAway();
+            emit({ type: 'isolated', id: env[ACTIVE_MUTANT_ENV] ?? ns.activeMutant, killed: failed.length > 0 && !timeout, failed, ran, ...(timeout && { timeout }) });
         }
         return super.onAfterRunFiles?.(files);
     }

package/dist/runtime.js

@@ -18,6 +18,7 @@ export const ACTIVE_MUTANT_ENV = '__OXMUTATE_ACTIVE_MUTANT__';
 // place the package touches it. `env` is the live object: a write here is a write to the process.
 export const env = process.env;
 export const argv = process.argv;
+export const pid = process.pid;
 export const cwd = () => process.cwd();
 export const stderr = process.stderr;
 export const exit = (code) => process.exit(code);