oxmutate 1.0.2 → 1.1.0

package/README.md

@@ -45,7 +45,7 @@ oxc, not affiliated with the oxc project.
 
 | | Stryker 10 | oxmutate 1.0 |
 | :-- | :-- | :-- |
-| Mutant set | 17 mutator families | the same 17, the same mutants (720 of 720 on es-toolkit) |
+| Mutant set | 17 mutator families | the same 17, the same mutants (720 of 720 on es-toolkit), plus `NumericLiteral` (0 → 1, 1 → 0, n → n + 1): +6.6% mutants on burgee/paratext, 19 of them survivors Stryker cannot report. `--stryker-compat` gives Stryker's set exactly |
 | Verdicts | — | the same as Stryker's on 99.9% of mutants ([measured](#compatibility)) |
 | Instrumentation | Babel, file by file | Rust on oxc, every file in parallel: 720 mutants in 35 ms |
 | Test runs | a Vitest run per mutant | each covering test re-run per mutant inside a warm Vitest worker |
@@ -187,10 +187,10 @@ setting a value inside the worker that already has the tests loaded.
 | :-- | :-- |
 | The dry run must pass | A suite that fails with no mutant armed scores nothing (exit 3) |
 | Re-parse | Every instrumented file is parsed again before it runs; one that does not parse stops the run (exit 3) instead of scoring a broken file |
-| Canary | The unmutated test must still pass after mutants run in a context; if a mutant left a cache, a registry or a fixture behind, the context restarts and the suspect verdicts run again |
+| Canary | The unmutated test must still pass after mutants run in a context, with its `beforeEach`/`afterEach` hooks re-run around every run, file-level ones included; if a mutant left a cache, a registry or a fixture behind, the context restarts and the suspect verdicts run again. A kill that follows unchecked runs is checked at once and decided again from clean state, so no kill rests on another mutant's leftovers |
 | Survivor confirmation | A survivor is re-run with the mutant armed across its covering tests in one file, as Stryker arms it, so a mutant that only fails across tests is killed |
 | Watchdog | A synchronous runaway is stopped and its server replaced; the stop is re-run at 3x the budget before it is reported as a timeout |
-| Static mutants | Code that runs at import is re-run with the mutant armed from process start, against the files that load it |
+| Static mutants | Code that runs at import is decided in a live worker: the mutant is armed, the module registry reset and the test file collected again, against the files that load it. A file whose collection changes globals, `process.env` or a built-in prototype, or a mutant that leaves a trace, goes back to a fresh worker per mutant (`OXMUTATE_ISOLATE_STATIC=1` sends all of them there) |
 | Flaky tests | Tests that behave differently across two dry runs have their mutants re-run; a verdict that changes is reported `flaky` |
 | No orphans | Every Vitest server exits when its run does, killed or not |
 
@@ -249,11 +249,19 @@ Of the two disagreements left, one is a Stryker timeout on a loop that ends (its
 it; the covering tests pass). The other is a mutant Stryker scored as a runtime error, so it has
 no Stryker verdict to compare.
 
-**Speed is not yet a published number.** On a shared laptop, paratext took 180.0 s under oxmutate
-and 427.4 s under Stryker, at 0.375 and 0.620 CPU-seconds a mutant; on controlroom oxmutate used
-less CPU (0.092 against 0.171 CPU-seconds a mutant) and was slower by the wall clock (107.2 s
-against 94.3 s). The laptop's load moved a run by more than the difference, so the wall-clock
-figures to publish will come from the `oxmutate-bench.yml` lane on a runner nothing else shares.
+**Speed, measured on a laptop, not yet a published number** (the published ones live at
+[burgee.interlace.tools/docs/benchmarks](https://burgee.interlace.tools/docs/benchmarks)). Medians of 3
+head-to-head runs (`bench/burgee-pair.mts`, concurrency 4, one tool after the other, load 6–19, 2026-10-30):
+
+| Subject | Stryker 10 | oxmutate | Wall | CPU | Tests a mutant |
+| :-- | --: | --: | --: | --: | --: |
+| burgee/paratext | 108.3 s | 19.0 s | 5.70x | 5.92x | 31.7 → 16.8 |
+| burgee/controlroom | 63.4 s | 45.6 s | 1.39x | 2.55x | 7.3 → 9.2 |
+| oxmutate itself (Stryker's mutant set) | 508 s | 334 s | 1.52x | — | — |
+
+The ceiling depends on the suite as much as the tool: controlroom's own `vitest run` takes ~8 s and
+every fresh worker imports React and Ink, so even zero overhead would make it ~6x. The figures to
+publish will come from the `oxmutate-bench.yml` lane on a runner nothing else shares.
 
 ## Benchmarks
 

package/dist/checker.js

@@ -29,6 +29,7 @@ export function applyMutant(source, m) {
     const starts = [0];
     for (let i = source.indexOf('\n'); i !== -1; i = source.indexOf('\n', i + 1))
         starts.push(i + 1);
+    // Stryker disable next-line NumericLiteral: `starts` holds every line the checker reports, so the fallback never runs
     const at = (p) => (starts[p.line - 1] ?? 0) + p.column - 1;
     return source.slice(0, at(m.start)) + m.replacement + source.slice(at(m.end));
 }

package/dist/child.js

@@ -42,6 +42,7 @@ const vitest = await vitestNode.createVitest('test', {
     // spellings (top-level in Vitest 5, `experimental` in 4.x).
     fsModuleCache: false,
     experimental: { fsModuleCache: false },
+    ...(config.inlineDeps && { server: { deps: { inline: true } } }),
 }, 
 // A private Vite cache per run, so no cache outside this run can answer for a mutated file.
 { plugins: [instrumentedSources(config.instrumentedMap)], cacheDir: path.join(path.dirname(config.instrumentedMap), 'vite-cache') });
@@ -72,6 +73,11 @@ async function runIsolated(unit) {
     try {
         for (const item of unit.batch ?? []) {
             env[ACTIVE_MUTANT_ENV] = item.id;
+            // The runaway guard warm runs have: a loop the mutant causes stops at the limit, not the watchdog.
+            if (item.hitLimit)
+                env['OXMUTATE_HIT_LIMIT'] = String(item.hitLimit);
+            else
+                delete env['OXMUTATE_HIT_LIMIT'];
             if (item.tests)
                 env['OXMUTATE_ONLY_TESTS'] = JSON.stringify(item.tests);
             else
@@ -87,6 +93,7 @@ async function runIsolated(unit) {
         }
         delete env[ACTIVE_MUTANT_ENV];
         delete env['OXMUTATE_ONLY_TESTS'];
+        delete env['OXMUTATE_HIT_LIMIT'];
     }
     finally {
         vitest.config.bail = 0;
@@ -101,6 +108,14 @@ async function runUnit(unit) {
     env['OXMUTATE_PROGRESS'] = unit.progress;
     if (unit.plan)
         env['OXMUTATE_PLAN'] = unit.plan;
+    if (unit.staticIds)
+        env['OXMUTATE_STATIC'] = JSON.stringify(unit.staticIds);
+    else
+        delete env['OXMUTATE_STATIC'];
+    if (unit.hitLimits)
+        env['OXMUTATE_HIT_LIMITS'] = JSON.stringify(unit.hitLimits);
+    else
+        delete env['OXMUTATE_HIT_LIMITS'];
     delete env[ACTIVE_MUTANT_ENV];
     if (unit.mode === 'isolated')
         await runIsolated(unit);

package/dist/coordinator.js

@@ -36,8 +36,14 @@ function readRecords(file) {
         .map((l) => JSON.parse(l));
 }
 const sha = (s) => createHash('sha256').update(s).digest('hex').slice(0, 16);
-/** Work units of at most this many (mutant, test) executions: small enough to steal. */
-const UNIT_PAIRS = 120;
+/**
+ * Work units of at most this many (mutant, test) executions: small enough to steal, large enough
+ * that each unit's fresh worker, which imports the test file's whole graph, is paid for few units.
+ * At 120, module loading was most of the CPU on burgee/controlroom (React/Ink in every worker); 400
+ * cut units 172 -> 93 and wall 44 -> 39 s (paratext 39 -> 35 s), and 1000 gained nothing more
+ * (2026-10-30). Smaller stays better for a pollution restart, which re-runs the rest of a unit.
+ */
+const UNIT_PAIRS = 400;
 const MS_PER_MINUTE = 60_000;
 const PERCENT = 100;
 /** Every test that reaches a mutant: the score's, then a spec oracle's replay tests. */
@@ -214,8 +220,10 @@ export async function run(options) {
         for (const [testId, perMutant] of Object.entries(dry.perTest)) {
             if (testId.startsWith(FILE_KEY)) {
                 const file = testId.slice(FILE_KEY.length);
-                for (const id of Object.keys(perMutant))
+                for (const [id, n] of Object.entries(perMutant)) {
                     (staticFiles.get(id) ?? staticFiles.set(id, new Set()).get(id))?.add(file);
+                    hits.set(id, (hits.get(id) ?? 0) + n);
+                }
                 continue;
             }
             for (const [id, n] of Object.entries(perMutant)) {
@@ -294,7 +302,9 @@ export async function run(options) {
         // false kills on burgee/paratext (an import-time registration the tests then read).
         const toRun = mutants.filter((m) => !m.reused && m.status !== 'Ignored' && !m.static && allCovering(m).length > 0);
         const byId = new Map(mutants.map((m) => [m.id, m]));
-        const hitLimits = Object.fromEntries(toRun.map((m) => [m.id, Math.max(1000, (hits.get(m.id) ?? 1) * 100)]));
+        /** The switch-taken count past which a run is a runaway: 100x what the dry run saw, at least 1000. */
+        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)); };
         // The watchdog is for runaways, which loop in fast code; a slow test under a loaded machine is
         // not one. 3x the covering test's dry-run time, not Stryker's 1.5x: at 1.5x, subprocess-heavy
@@ -357,7 +367,8 @@ export async function run(options) {
         const records = [];
         const runaways = new Set();
         const crashedIds = new Set();
-        const pool = createPool({ root, vitestConfig: options.vitestConfig, workers: 1, instrumentedMap: mapFile, nodeArgs: options.testRunnerNodeArgs }, options.concurrency, work, 'mutant');
+        // Dependencies inlined here too, so the static phase (5b) reuses these servers instead of starting its own.
+        const pool = createPool({ root, vitestConfig: options.vitestConfig, workers: 1, instrumentedMap: mapFile, nodeArgs: options.testRunnerNodeArgs, inlineDeps: true }, options.concurrency, work, 'mutant');
         pools.push(pool);
         /** Mutants decided on one verdict track: the tests', or a spec oracle's replay tests'. */
         const killedSoFar = (spec) => new Set([...runaways, ...crashedIds, ...records.filter((r) => r.type === 'mutant' && r.status !== 'Survived' && Boolean(r.spec) === spec).map((r) => r.id ?? '')]);
@@ -410,7 +421,29 @@ export async function run(options) {
         // One round, every covering file at once. A two-round plan (cheapest file first, survivors
         // to the rest) cut executions 23% on burgee/paratext but took 2.9x longer: the second round
         // waits for the first to drain, and the expensive files then run as a tail (2026-10-27).
-        await pool.drain(unitsForRound(toRun, (m) => fileOrder.get(m.id) ?? []), (_, id) => warmBudget(id), afterUnit);
+        // Kills are filtered out at dispatch, not when a unit is built: most units wait in the queue while
+        // others run, and a mutant another unit has killed (vouched for by its canary) needs no more of its
+        // covering tests. 1,022 of 6,550 warm executions on burgee/paratext ran after the mutant's kill
+        // (2026-10-30). Verdicts are unchanged: a Killed mutant needs no other pair (dispatch.qnt).
+        const beforeUnit = (unit) => {
+            const entry = planUnits.get(unit.results);
+            if (!entry)
+                return true;
+            const decided = { tests: killedSoFar(false), spec: killedSoFar(true) };
+            const left = {};
+            for (const [t, ids] of Object.entries(entry.plan)) {
+                const done = specOf.has(t) ? decided.spec : decided.tests;
+                const keep = ids.filter((id) => !done.has(id));
+                if (keep.length)
+                    left[t] = keep;
+            }
+            if (Object.keys(left).length === 0)
+                return false;
+            entry.plan = left;
+            writeFileSync(unit.plan, JSON.stringify({ tests: left, hitLimits, skip: [], specTests: [...specOf.keys()] }));
+            return true;
+        };
+        await pool.drain(unitsForRound(toRun, (m) => fileOrder.get(m.id) ?? []), (_, id) => warmBudget(id), afterUnit, beforeUnit);
         stats.mutationMs = performance.now() - m0;
         // ── 5. Verdicts from the warm run ─────────────────────────────────────────────────────────
         const byMutant = new Map();
@@ -449,9 +482,7 @@ export async function run(options) {
                 isolatedQueue.push(m); // unfinished: a crash left work undone
             }
         }
-        for (const m of mutants)
-            if (m.static && m.status !== 'Ignored' && !m.reused)
-                isolatedQueue.push(m);
+        const staticMutants = mutants.filter((m) => m.static && m.status !== 'Ignored' && !m.reused);
         // ── 6. Isolated re-runs: the switch armed before import, Vitest run normally ──────────────
         const allTestFiles = [...new Set(dry.tests.map((t) => t.file))];
         // A static mutant needs the files that load it (plus any whose tests reach it); only a hit
@@ -460,6 +491,21 @@ export async function run(options) {
         for (const t of dry.tests)
             fileCost.set(t.file, (fileCost.get(t.file) ?? 0) + t.ms);
         const byCost = (files) => [...files].sort((a, b) => (fileCost.get(a) ?? 0) - (fileCost.get(b) ?? 0));
+        // Test file -> source file -> how many of that source's mutants its tests reach. A static mutant
+        // rarely has covering tests of its own, so its loaders were tried cheapest first, and the cheapest
+        // seldom tests the module: on burgee/controlroom each tabs.ts static mutant ran 75 tests in two
+        // files where Stryker needed 37 (2026-10-30). The file that exercises the module goes first.
+        const affinity = new Map();
+        for (const mm of mutants) {
+            for (const t of mm.coveredBy) {
+                const f = testInfo.get(t)?.file;
+                if (!f)
+                    continue;
+                const bySource = affinity.get(f) ?? affinity.set(f, new Map()).get(f);
+                bySource.set(mm.file, (bySource.get(mm.file) ?? 0) + 1);
+            }
+        }
+        const byAffinity = (source, files) => byCost(files).sort((a, b) => (affinity.get(b)?.get(source) ?? 0) - (affinity.get(a)?.get(source) ?? 0));
         const filesFor = (m) => {
             const tests = m.coveredBy.map((t) => testInfo.get(t)?.file ?? '');
             if (!m.static)
@@ -471,27 +517,119 @@ export async function run(options) {
             // ran a file that only imports it first, and 288 of 349 isolated kills on burgee/paratext
             // came from a later file (2026-10-27).
             const covering = byCost([...new Set(tests)]);
-            return [...covering, ...byCost([...loaders].filter((f) => !covering.includes(f)))];
+            return [...covering, ...byAffinity(m.file, [...loaders].filter((f) => !covering.includes(f)))];
         };
         const isolatedBudget = (id) => {
             const m = byId.get(id);
             const fs = m ? filesFor(m) : allTestFiles;
-            const ms = dry.tests.filter((t) => fs.includes(t.file)).reduce((sum, t) => sum + t.ms, 0);
+            // A non-static mutant's isolated run executes only its covering tests (`tests` below), so they
+            // are its budget; every test of its files made a hang wait 30-40 s on oxmutate's own suite,
+            // where its covering tests take a fraction of that (2026-10-30). A static mutant runs them all.
+            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;
         };
         // A non-static mutant runs only its covering tests, armed across all of them in file order:
         // Stryker's semantics, so cross-test effects still show (a no-op reset() lets state pile up
         // for the next covering test). A static mutant runs every test of its files, because an
         // import-time change reaches tests that never execute the mutated line.
+        /**
+         * Static mutants decided in live workers, one unit per (test file, batch of its static mutants),
+         * on a pool that inlines dependencies. Returns the mutants this path could not decide.
+         */
+        const decideStaticLive = async (items) => {
+            if (items.length === 0)
+                return [];
+            const STATIC_BATCH = 25;
+            /** Units of up to STATIC_BATCH mutants per test file, for the files each mutant gets this round. */
+            const unitsFor = (filesOf) => {
+                const byFile = new Map();
+                for (const m of items)
+                    for (const f of filesOf(m))
+                        (byFile.get(f) ?? byFile.set(f, []).get(f))?.push(m.id);
+                return [...byFile].flatMap(([file, ids]) => Array.from({ length: Math.ceil(ids.length / STATIC_BATCH) }, (_, i) => ({
+                    mode: 'static', files: [file], results: fileFor('static', 'jsonl'), progress: fileFor('static', 'progress'), staticIds: ids.slice(i * STATIC_BATCH, (i + 1) * STATIC_BATCH),
+                    hitLimits: Object.fromEntries(ids.slice(i * STATIC_BATCH, (i + 1) * STATIC_BATCH).map((id) => [id, hitLimitOf(id)])),
+                })));
+            };
+            const killed = new Map();
+            /** Decided by the hit-count limit: a runaway, Timeout like a warm one. */
+            const timedOut = new Set();
+            const passed = new Map(); // mutant -> files that ran it clean
+            const back = new Set();
+            const ran = new Map();
+            const staticPool = pool;
+            const afterStatic = (unit, outcome) => {
+                const file = unit.files[0] ?? '';
+                const decided = new Set();
+                for (const r of readRecords(unit.results)) {
+                    if (r.type === 'static-fallback')
+                        for (const id of r.ids ?? [])
+                            back.add(id);
+                    if (r.type !== 'isolated' || !r.id)
+                        continue;
+                    decided.add(r.id);
+                    ran.set(r.id, (ran.get(r.id) ?? 0) + (r.ran ?? 0));
+                    if (r.timeout)
+                        timedOut.add(r.id);
+                    if (r.killed || r.timeout)
+                        killed.set(r.id, { killedBy: [...(killed.get(r.id)?.killedBy ?? []), ...(r.failed ?? [])], ran: 0 });
+                    else
+                        (passed.get(r.id) ?? passed.set(r.id, new Set()).get(r.id))?.add(file);
+                }
+                // A stop or a crash leaves the rest of the batch undecided: the fresh-worker path decides it.
+                if (outcome.killedFor || outcome.crashed)
+                    for (const id of unit.staticIds ?? [])
+                        if (!decided.has(id))
+                            back.add(id);
+                return [];
+            };
+            const keepUndecided = (unit) => {
+                unit.staticIds = (unit.staticIds ?? []).filter((id) => !killed.has(id) && !back.has(id));
+                return unit.staticIds.length > 0;
+            };
+            // Two rounds: each mutant first in the file most likely to kill it (filesFor puts the files whose
+            // tests reach it first, cheapest first), then its other files only if it survived. In one round
+            // every loading file ran a mutant at once, and a kill in one did not spare the others: 41 tests a
+            // static kill on burgee/controlroom against Stryker's 33.6 (2026-10-30).
+            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) : [])];
+            // the mutant's run and the unarmed canary after it
+            for (const round of rounds)
+                await staticPool.drain(unitsFor(round), (_, id) => 2 * isolatedBudget(id), afterStatic, keepUndecided);
+            const undecided = [];
+            for (const m of items) {
+                const k = killed.get(m.id);
+                if (k) {
+                    m.status = timedOut.has(m.id) && !k.killedBy.length ? 'Timeout' : 'Killed';
+                    m.killedBy = [...new Set(k.killedBy)];
+                    m.testsCompleted = ran.get(m.id) ?? 0;
+                }
+                else if (!back.has(m.id) && filesFor(m).every((f) => passed.get(m.id)?.has(f))) {
+                    m.status = 'Survived';
+                    m.testsCompleted = ran.get(m.id) ?? 0;
+                }
+                else
+                    undecided.push(m);
+            }
+            return undecided;
+        };
         const runIsolated = async (items, slack = 1) => {
             const verdicts = new Map();
             if (items.length === 0)
                 return verdicts;
-            const chunk = Math.max(1, Math.ceil(items.length / (options.concurrency * 2)));
-            const mk = (batch) => ({ mode: 'isolated', files: [], results: fileFor('iso', 'jsonl'), progress: fileFor('iso', 'progress'), batch: batch.map((m) => ({ id: m.id, files: filesFor(m), tests: m.static ? undefined : m.coveredBy })) });
-            const units = [];
-            for (let i = 0; i < items.length; i += chunk)
-                units.push(mk(items.slice(i, i + chunk)));
+            const mk = (batch) => ({ mode: 'isolated', files: [], results: fileFor('iso', 'jsonl'), progress: fileFor('iso', 'progress'), batch: batch.map((m) => ({ id: m.id, files: filesFor(m), tests: m.static ? undefined : m.coveredBy, hitLimit: hitLimitOf(m.id) })) });
+            // Packed by estimated cost, heaviest first into the lightest bin, and the heaviest bins run
+            // first. Equal mutant counts left one unit at 8.4 s while the others finished in under 3 s on
+            // burgee/controlroom (2026-10-30): a mutant's cost is its files' dry-run time, not one.
+            const cost = (m) => isolatedBudget(m.id);
+            const bins = Array.from({ length: Math.min(items.length, options.concurrency * 2) }, () => ({ load: 0, batch: [] }));
+            for (const m of [...items].sort((x, y) => cost(y) - cost(x))) {
+                const bin = bins.reduce((lightest, b) => (b.load < lightest.load ? b : lightest));
+                bin.load += cost(m);
+                bin.batch.push(m);
+            }
+            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) => {
                 // Vitest reports per test file: a mutant is killed if any of its files failed.
@@ -500,7 +638,9 @@ export async function run(options) {
                         continue;
                     const prev = verdicts.get(rec.id);
                     const testsCompleted = (prev?.testsCompleted ?? 0) + (rec.ran ?? 0);
-                    if (rec.killed)
+                    if (rec.timeout)
+                        verdicts.set(rec.id, { status: 'Timeout', testsCompleted });
+                    else if (rec.killed)
                         verdicts.set(rec.id, { status: 'Killed', killedBy: [...(prev?.killedBy ?? []), ...(rec.failed ?? [])], testsCompleted });
                     else
                         verdicts.set(rec.id, { status: prev?.status ?? 'Survived', killedBy: prev?.killedBy, testsCompleted });
@@ -520,6 +660,13 @@ export async function run(options) {
                     verdicts.set(m.id, { status: 'RuntimeError' });
             return verdicts;
         };
+        // ── 5b. Static mutants in live workers (.sdlc/intents/oxmutate/staticwarm.qnt) ─────────────
+        // A fresh worker per (static mutant, file) cost ~80 ms of start-up around tests that take a few
+        // ms: 29 of 35 s on burgee/paratext (2026-10-30). A live worker re-evaluates the project's modules
+        // per mutant instead; whatever it cannot vouch for comes back here for the fresh-worker path.
+        // OXMUTATE_ISOLATE_STATIC=1 sends every static mutant down the fresh-worker path, as before.
+        const staticBack = env['OXMUTATE_ISOLATE_STATIC'] ? staticMutants : await decideStaticLive(staticMutants);
+        isolatedQueue.push(...staticBack);
         progress.phase(`isolated runs (static mutants and stragglers: ${String(isolatedQueue.length)})`);
         const i0 = performance.now();
         const first = await runIsolated(isolatedQueue);
@@ -551,7 +698,10 @@ export async function run(options) {
         // survives warm and is killed when armed for the whole file, the way Stryker runs it (burgee/
         // paratext plugin.ts, 2026-10-27). Survivors are what a person acts on, so each one is
         // re-run once with the mutant armed across its covering files before it is reported.
-        const survivors = toRun.filter((m) => m.status === 'Survived');
+        // A survivor with one covering test is not re-run: confirmation runs only covering tests, so there
+        // is no later test for its leftover state to reach, and the warm run already armed that test
+        // through its hooks from clean state (.sdlc/intents/oxmutate/confirm.qnt).
+        const survivors = toRun.filter((m) => m.status === 'Survived' && new Set(m.coveredBy).size > 1);
         const confirmed = await runIsolated(survivors);
         // A timeout here is a watchdog stop like any other, and a loaded machine makes them: two
         // closeout survivors were reported killed this way while a docs build shared the machine

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/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.
@@ -69,6 +74,53 @@ 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;
 /** Mutants between canaries; doubles while the canary stays clean, back to 1 when it fails. */
@@ -81,10 +133,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 +165,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)
@@ -147,11 +260,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 +292,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 +316,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 +359,96 @@ 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;
+            }
+        };
+        while (rest.length) {
+            const id = rest[0];
+            if (progressPath)
+                writeFileSync(progressPath, `${id} ${String(Date.now())}\n`);
+            const verdict = await evaluate(id);
+            const left = snapshotDiff(before, snapshot());
+            if (left.length)
+                return fallback('the mutant left a trace', left);
+            const unarmed = await evaluate(undefined);
+            if (unarmed.failed.length > 0)
+                return fallback('the unarmed re-collection failed', unarmed.error ? [unarmed.error] : []);
+            const after = snapshotDiff(before, snapshot());
+            if (after.length)
+                return fallback('the unarmed re-collection left a trace', after);
+            rest.shift();
+            emit({ type: 'isolated', id, killed: verdict.failed.length > 0 && !verdict.timeout, failed: verdict.failed, ran: verdict.ran, ...(verdict.timeout && { timeout: true }) });
+        }
+        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 +491,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/scheduler.js

@@ -118,7 +118,7 @@ export function createPool(config, size, workDir, tag) {
     };
     return {
         stats,
-        async drain(units, budget, after) {
+        async drain(units, budget, after, prepare) {
             const queue = [...units];
             let busy = 0;
             const waiters = [];
@@ -126,9 +126,16 @@ export function createPool(config, size, workDir, tag) {
                 for (const w of waiters.splice(0))
                     w();
             };
+            /** The next unit `prepare` keeps, or undefined when the queue is empty. */
+            const take = () => {
+                for (let unit = queue.shift(); unit; unit = queue.shift())
+                    if (!prepare || prepare(unit))
+                        return unit;
+                return undefined;
+            };
             await Promise.all(servers.map(async (_, slot) => {
                 for (;;) {
-                    const unit = queue.shift();
+                    const unit = take();
                     if (!unit) {
                         if (busy === 0) {
                             signal();

package/dist/spec-oracle.js

@@ -45,6 +45,7 @@ const share = (n, of) => (of ? (PERCENT * n) / of : 0);
 const located = ({ id, file, line, mutatorName, replacement }) => ({ id, file, line, mutatorName, replacement });
 const median = (xs) => {
     const sorted = [...xs].sort((a, b) => a - b);
+    // Stryker disable next-line NumericLiteral: guarded by `sorted.length`, so the fallback never runs
     return sorted.length ? (sorted[Math.floor(sorted.length / 2)] ?? 0) : 0;
 };
 const testsMiss = (m) => m.status === 'Survived' || m.status === 'NoCoverage';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxmutate",
-  "version": "1.0.2",
+  "version": "1.1.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": {