@polymorphism-tech/morph-spec 8.41.0 → 8.43.0

package/src/lib/mutation/runner.js

@@ -0,0 +1,351 @@
+import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { applyRegions, diffOf } from './manifest.js';
+import { blame, parseCompilerErrors, patchFile, switchClassName, switchSource, SWITCH_ENV } from './schemata.js';
+import { md5Of, md5OfFile, openSnapshot, restoreSnapshot, trackGenerated } from './snapshot.js';
+import { parseBuiltDlls } from './commands.js';
+import { firstLines, methodOf } from './trx.js';
+import { nearestProjectOf } from '../tasks/dotnet-test-introspection.js';
+
+const posix = (p) => p.replace(/\\/g, '/');
+const MAX_SCHEMATA_ATTEMPTS = 3;
+const MAX_REPRODUCE = 5;
+
+const envWithout = (env) => { const { [SWITCH_ENV]: _drop, ...rest } = env; return rest; };
+const failedNames = (result) => new Set(result.failedTests.map((t) => t.name));
+
+function newFailures(result, baseline) {
+  const known = baseline ? failedNames(baseline) : new Set();
+  return result.failedTests.filter((t) => !known.has(t.name));
+}
+
+function reasonOf(failures) {
+  const [first] = failures;
+  if (!first) return '';
+  const text = firstLines(first.message);
+  return text ? `${first.name}: ${text}` : first.name;
+}
+
+/**
+ * Judges one test result against the same scope's baseline: killed needs a
+ * failure the pristine run did not have; a run that executed nothing or died
+ * proves nothing either way.
+ */
+export function judge(result, baseline) {
+  if (result.outcome === 'crash') return { state: 'inconclusive', reason: result.note ?? 'a rodada não terminou' };
+  if (result.executed === 0) return { state: 'inconclusive', reason: 'nenhum teste foi executado neste escopo' };
+  if (result.outcome === 'red') {
+    const fresh = newFailures(result, baseline);
+    if (fresh.length > 0) return { state: 'killed', failures: fresh, reason: reasonOf(fresh) };
+  }
+  return { state: 'survived' };
+}
+
+const carriesSwitch = (dll) => readFileSync(dll).includes(Buffer.from(SWITCH_ENV, 'utf16le'));
+
+/**
+ * Equal bytes against the DLL built from the clean tree is the proof. A non-deterministic
+ * build can only show it was rebuilt AFTER the restore and carries no switch.
+ */
+export function proveBinary({ pristine, dlls, restoredAt, hashes }) {
+  const projects = [...pristine].map(([name, md5]) => {
+    const dll = dlls.get(name);
+    const final = hashes.get(name) ?? null;
+    const rebuilt = Boolean(dll) && statSync(dll).mtimeMs >= restoredAt - 50;
+    return { name, pristine: md5, final, equal: final === md5, rebuilt, switchLeft: Boolean(dll) && carriesSwitch(dll) };
+  });
+  if (projects.length === 0) return { proof: 'unlocated', projects };
+  if (projects.some((p) => p.switchLeft)) return { proof: 'mismatch', projects };
+  if (projects.every((p) => p.equal)) return { proof: 'md5', projects };
+  return { proof: projects.every((p) => p.rebuilt) ? 'rebuilt' : 'mismatch', projects };
+}
+
+async function pool(items, size, worker) {
+  const queue = [...items];
+  await Promise.all(Array.from({ length: Math.min(size, queue.length) }, async () => {
+    while (queue.length > 0) await worker(queue.shift());
+  }));
+}
+
+function mergeBaselines(copies) {
+  const [first] = copies;
+  const broken = copies.find((c) => c.outcome === 'crash');
+  if (broken) return broken;
+  const seen = new Map();
+  for (const c of copies) for (const t of c.failedTests) if (!seen.has(t.name)) seen.set(t.name, t);
+  const failedTests = [...seen.values()];
+  return { ...first, outcome: failedTests.length > 0 ? 'red' : 'green', failed: failedTests.length, failedTests };
+}
+
+export async function runMutation(input) {
+  const { root, node, regions, workDir, runId, exec, adapter, gate, git, log = () => {}, options = {} } = input;
+  const timeoutMs = options.timeoutMs ?? node.timeoutMs ?? 900_000;
+  const startedAt = Date.now();
+  let workerCount = 1;
+  const timings = [];
+  const timed = async (label, fn) => {
+    const at = Date.now();
+    try { return await fn(); } finally { timings.push({ label, ms: Date.now() - at }); }
+  };
+
+  const files = [...new Set(regions.map((r) => r.file))];
+  const originals = new Map(files.map((f) => [f, readFileSync(join(root, f), 'utf8')]));
+  const porcelainBefore = git.porcelain();
+  const snapshot = openSnapshot({ dir: join(workDir, 'snapshot'), root, files, runId });
+  const projectOf = (file) => {
+    const csproj = nearestProjectOf(join(root, file), root);
+    return csproj ? { rel: posix(relative(root, csproj)), dir: dirname(csproj), name: basename(csproj).replace(/\.[a-z]+proj$/i, '') } : null;
+  };
+
+  const results = new Map(regions.map((r) => [r.id, {
+    id: r.id, file: r.file, line: r.line, diff: diffOf(r), note: r.note,
+    md5Before: md5Of(readFileSync(join(root, r.file))),
+    md5After: md5Of(applyRegions(originals.get(r.file), [r], (x) => x.replaceText).text),
+    mode: r.mode === 'rebuild' || adapter.kind !== 'dotnet' || !/\.cs$/i.test(r.file) ? 'rebuild' : 'schemata',
+    demoted: null, verdict: null, scope: null, killers: 0, executed: null, reason: '', durationMs: 0,
+  }]));
+  const byId = new Map(regions.map((r) => [r.id, r]));
+
+  const build = async (label) => {
+    const dlls = new Map();
+    for (const command of adapter.buildCommands) {
+      const r = await timed(label, () => exec(command, { cwd: adapter.cwd, env: process.env, timeoutMs, label }));
+      const output = `${r.stdout}\n${r.stderr}`;
+      if (r.status !== 0) return { ok: false, output };
+      for (const [name, dll] of parseBuiltDlls(output)) dlls.set(name, dll);
+    }
+    return { ok: true, dlls };
+  };
+
+  const dllHashes = (dlls) => new Map(
+    [...new Set(files.map((f) => projectOf(f)?.name).filter(Boolean))]
+      .filter((name) => dlls.has(name) && existsSync(dlls.get(name)))
+      .map((name) => [name, md5OfFile(dlls.get(name))]),
+  );
+
+  const run = (scope, label, env) => timed(label, () => adapter.runTests({ scope, label, env }));
+
+  const confirmKill = async (id, verdict, env) => {
+    if (!adapter.reproduce) return verdict;
+    const names = [...new Set(verdict.failures.map((f) => f.name))].slice(0, MAX_REPRODUCE);
+    const again = await timed(`${id}-reproduce`, () => adapter.reproduce({ names, label: `${id}-reproduce`, env }));
+    if (again.outcome === 'crash' || !again.executed) {
+      return { state: 'inconclusive', reason: `a falha de ${names[0]} não pôde ser confirmada na repetição (${again.note ?? 'nenhum teste executado'})` };
+    }
+    const wanted = new Set(names.map(methodOf));
+    const held = again.failedTests.filter((t) => wanted.has(methodOf(t.name)));
+    if (held.length > 0) return { ...verdict, reason: reasonOf(held) };
+    const whole = await timed(`${id}-reproduce-full`, () => adapter.runTests({ scope: 'full', label: `${id}-reproduce-full`, env }));
+    if (whole.outcome === 'crash' || !whole.executed) {
+      return { state: 'inconclusive', reason: `a falha de ${names[0]} não pôde ser confirmada na repetição (${whole.note ?? 'nenhum teste executado'})` };
+    }
+    const heldWhole = whole.failedTests.filter((t) => wanted.has(methodOf(t.name)));
+    if (heldWhole.length > 0) return { ...verdict, reason: reasonOf(heldWhole) };
+    const which = names.length === 1 ? names[0] : `${names.length} testes`;
+    return { state: 'survived', reason: `nenhum teste falhou de forma reproduzível: ${which} falhou uma vez e passou isolado e na suíte inteira repetida (instável, não prova o mutante)` };
+  };
+
+  const record = (id, patch) => Object.assign(results.get(id), patch);
+  const applyOnDisk = (id) => {
+    const region = byId.get(id);
+    writeFileSync(join(root, region.file), applyRegions(originals.get(region.file), [region], (x) => x.replaceText).text);
+  };
+
+  let pristine = new Map();
+  let binary = { proof: 'unavailable', projects: [] };
+  let baselineSubset = null;
+  let baselineFull = null;
+  let subsetLive = adapter.hasSubset;
+  let subsetNote = null;
+  const needFullBaseline = [];
+  let restoreReport = [];
+
+  try {
+    gate?.enter('mutate');
+
+    if (adapter.buildCommands.length > 0) {
+      restoreSnapshot(snapshot);
+      const first = await build('build-pristine');
+      if (!first.ok) throw Object.assign(new Error('a árvore não compila ANTES da mutação — nada foi mutado'), { code: 'baseline-build-failed', output: first.output });
+      pristine = dllHashes(first.dlls);
+    }
+
+    const compileErrorOf = (output, fallback) => firstLines(parseCompilerErrors(output).map((e) => `${e.code} ${e.message}`)[0] ?? fallback);
+
+    const screenLiteral = async (ids) => {
+      let remaining = ids;
+      for (let attempt = 0; attempt < MAX_SCHEMATA_ATTEMPTS && remaining.length > 0; attempt++) {
+        const patched = [];
+        for (const file of files) {
+          const own = remaining.map((id) => byId.get(id)).filter((r) => r.file === file);
+          if (own.length === 0) continue;
+          const { text, spans } = applyRegions(originals.get(file), own, (r) => r.replaceText);
+          writeFileSync(join(root, file), text);
+          patched.push({ abs: join(root, file), file, spans });
+        }
+        const b = await build('build-literal');
+        restoreSnapshot(snapshot);
+        if (b.ok) return remaining;
+        const { blamed, unmapped } = blame(parseCompilerErrors(b.output), patched);
+        const demote = unmapped.length > 0 || blamed.length === 0 ? [...remaining] : blamed;
+        const note = `a forma literal não compila (${compileErrorOf(b.output, 'erro de compilação')})`;
+        for (const id of demote) record(id, { mode: 'rebuild', demoted: note });
+        remaining = remaining.filter((id) => !demote.includes(id));
+      }
+      for (const id of remaining) record(id, { mode: 'rebuild', demoted: 'a triagem da forma literal não convergiu' });
+      return [];
+    };
+
+    let schemataIds = [...results.values()].filter((r) => r.mode === 'schemata').map((r) => r.id);
+    if (adapter.buildCommands.length > 0) schemataIds = await screenLiteral(schemataIds);
+    let schemataBuilt = false;
+    for (let attempt = 0; attempt < MAX_SCHEMATA_ATTEMPTS && schemataIds.length > 0; attempt++) {
+      const patched = [];
+      const classes = new Map();
+      for (const file of files) {
+        const own = schemataIds.map((id) => byId.get(id)).filter((r) => r.file === file);
+        if (own.length === 0) continue;
+        const project = projectOf(file);
+        const className = switchClassName(project.rel);
+        const { text, spans } = patchFile(originals.get(file), own, className);
+        writeFileSync(join(root, file), text);
+        patched.push({ abs: join(root, file), file, spans });
+        if (!classes.has(project.rel)) {
+          const generated = posix(relative(root, join(project.dir, `${className}.g.cs`)));
+          writeFileSync(join(root, generated), switchSource(className));
+          trackGenerated(snapshot, generated);
+          classes.set(project.rel, generated);
+        }
+      }
+      const b = await build('build-schemata');
+      if (b.ok) { schemataBuilt = true; break; }
+      const { blamed, unmapped } = blame(parseCompilerErrors(b.output), patched);
+      restoreSnapshot(snapshot);
+      const note = `schemata recusou — ${compileErrorOf(b.output, 'o build de schemata falhou')}`;
+      const demote = unmapped.length > 0 || blamed.length === 0 ? [...schemataIds] : blamed;
+      for (const id of demote) record(id, { mode: 'rebuild', demoted: note });
+      schemataIds = schemataIds.filter((id) => !demote.includes(id));
+    }
+    if (!schemataBuilt) {
+      for (const id of schemataIds) record(id, { mode: 'rebuild', demoted: 'schemata recusou — o build não convergiu' });
+      schemataIds = [];
+    } else {
+      restoreSnapshot(snapshot);
+    }
+
+    const hasRebuild = [...results.values()].some((r) => r.mode === 'rebuild');
+    const jobs = Math.max(1, Math.min(options.jobs ?? 1, gate?.jobs ?? options.jobs ?? 1));
+    if (subsetLive && (schemataIds.length > 0 || hasRebuild)) {
+      const copies = schemataIds.length > 0 ? jobs : 1;
+      baselineSubset = mergeBaselines(await Promise.all(Array.from({ length: copies }, (_, i) => (
+        run('subset', i === 0 ? 'baseline-subset' : `baseline-subset-${i + 1}`, envWithout(process.env))))));
+      if (baselineSubset.outcome === 'crash' || baselineSubset.executed === 0) {
+        subsetLive = false;
+        subsetNote = baselineSubset.executed === 0 ? 'o filtro do subconjunto não selecionou teste algum' : (baselineSubset.note ?? 'a rodada-base do subconjunto não terminou');
+      }
+    }
+    if (!subsetLive && schemataIds.length > 0) baselineFull = await run('full', 'baseline-full', envWithout(process.env));
+
+    const scopeOf = subsetLive ? 'subset' : 'full';
+    const scopeBaseline = () => (subsetLive ? baselineSubset : baselineFull);
+    const routed = [];
+    const scopeJobs = subsetLive ? jobs : 1;
+    workerCount = schemataIds.length > 0 ? scopeJobs : 1;
+    const outcomes = new Map();
+    await pool(schemataIds, scopeJobs, async (id) => {
+      outcomes.set(id, await run(scopeOf, `${id}-${scopeOf}`, { ...process.env, [SWITCH_ENV]: id }));
+    });
+    for (const id of schemataIds) {
+      const result = outcomes.get(id);
+      const first = judge(result, scopeBaseline());
+      const verdict = first.state === 'killed' && scopeOf === 'full' ? await confirmKill(id, first, { ...process.env, [SWITCH_ENV]: id }) : first;
+      const base = { scope: scopeOf, executed: result.executed, durationMs: result.durationMs };
+      if (verdict.state === 'killed') {
+        record(id, { ...base, verdict: 'killed', killers: verdict.failures.length, reason: verdict.reason });
+      } else {
+        record(id, { ...base, verdict: null, reason: verdict.reason ?? '' });
+        routed.push({ id, needs: 'full' });
+      }
+    }
+    for (const r of results.values()) if (r.mode === 'rebuild') routed.push({ id: r.id, needs: subsetLive ? 'subset-then-full' : 'full' });
+
+    for (const { id, needs } of routed) {
+      applyOnDisk(id);
+      try {
+        if (adapter.buildCommands.length > 0) {
+          const b = await build(`build-${id}`);
+          if (!b.ok) {
+            const err = parseCompilerErrors(b.output)[0];
+            record(id, { verdict: 'build-error', reason: err ? `${err.code} ${err.message}` : 'o mutante não compila', scope: null });
+            continue;
+          }
+        }
+        if (needs === 'subset-then-full') {
+          const sub = await run('subset', `${id}-subset`, envWithout(process.env));
+          const verdict = judge(sub, baselineSubset);
+          if (verdict.state === 'killed') {
+            record(id, { verdict: 'killed', scope: 'subset', killers: verdict.failures.length, executed: sub.executed, reason: verdict.reason, durationMs: sub.durationMs });
+            continue;
+          }
+        }
+        const full = await run('full', `${id}-full`, envWithout(process.env));
+        const first = judge(full, baselineFull);
+        const verdict = first.state === 'killed' ? await confirmKill(id, first, envWithout(process.env)) : first;
+        const base = { scope: 'full', executed: full.executed, durationMs: full.durationMs };
+        if (verdict.state === 'inconclusive') record(id, { ...base, verdict: 'inconclusive', reason: verdict.reason });
+        else if (verdict.state === 'survived') record(id, { ...base, verdict: 'survived', reason: verdict.reason ?? '' });
+        else { record(id, { ...base, verdict: 'killed', killers: verdict.failures.length, reason: verdict.reason }); if (!baselineFull) needFullBaseline.push({ id, full }); }
+      } finally {
+        restoreSnapshot(snapshot);
+      }
+    }
+
+    const restoredAt = Date.now();
+    restoreReport = restoreSnapshot(snapshot);
+    if (adapter.buildCommands.length > 0) {
+      const last = await build('build-final');
+      if (!last.ok) throw Object.assign(new Error('o rebuild final da árvore restaurada falhou'), { code: 'final-build-failed', output: last.output });
+      binary = proveBinary({ pristine, dlls: last.dlls, restoredAt, hashes: dllHashes(last.dlls) });
+    }
+
+    if (needFullBaseline.length > 0) {
+      baselineFull = await run('full', 'baseline-full', envWithout(process.env));
+      for (const { id, full } of needFullBaseline) {
+        const verdict = judge(full, baselineFull);
+        if (verdict.state === 'killed') record(id, { killers: verdict.failures.length, reason: verdict.reason });
+        else record(id, { verdict: 'survived', killers: 0, reason: '' });
+      }
+    }
+  } finally {
+    restoreReport = restoreSnapshot(snapshot, { rewrite: false });
+    gate?.release();
+  }
+
+  const porcelainAfter = git.porcelain();
+  const mutants = regions.map((r) => results.get(r.id));
+  return {
+    runId,
+    method: {
+      adapter: adapter.kind,
+      schemata: mutants.filter((m) => m.mode === 'schemata').length,
+      rebuild: mutants.filter((m) => m.mode === 'rebuild').length,
+      subset: { requested: adapter.hasSubset, live: subsetLive, note: subsetNote },
+      jobs: workerCount,
+    },
+    wallMs: Date.now() - startedAt,
+    mutants,
+    baseline: {
+      subset: baselineSubset ? { executed: baselineSubset.executed, failed: baselineSubset.failed } : null,
+      full: baselineFull ? { executed: baselineFull.executed, failed: baselineFull.failed } : null,
+    },
+    binary,
+    restore: {
+      files: restoreReport,
+      ok: restoreReport.every((f) => f.ok),
+      porcelainBefore,
+      porcelainAfter,
+      treeClean: porcelainBefore === porcelainAfter,
+    },
+    timings,
+  };
+}

package/src/lib/mutation/schemata.js

@@ -0,0 +1,60 @@
+import { createHash } from 'node:crypto';
+import { applyRegions } from './manifest.js';
+
+export const SWITCH_ENV = 'MORPH_MUTANT';
+
+export function switchClassName(csprojRel) {
+  return `MorphMutationSwitch_${createHash('md5').update(csprojRel).digest('hex').slice(0, 6)}`;
+}
+
+export function switchSource(className) {
+  return [
+    '// <auto-generated/>',
+    '#nullable enable',
+    '#pragma warning disable',
+    `internal static class ${className}`,
+    '{',
+    `    private static readonly string? Active = System.Environment.GetEnvironmentVariable("${SWITCH_ENV}");`,
+    '    internal static bool On(string id) => Active == id;',
+    '}',
+    '',
+  ].join('\n');
+}
+
+const wrap = (className, region) =>
+  `(${className}.On("${region.id}") ? (${region.replaceText}) : (${region.findText}))`;
+
+/**
+ * A C# file with every region behind its switch; the original text stays as the else branch.
+ * Each patched span comes back so a compiler error can be pinned on its mutant.
+ */
+export function patchFile(text, regions, className) {
+  return applyRegions(text, regions, (region) => wrap(className, region));
+}
+
+const MSBUILD_ERROR = /^(?<file>.+?)\((?<line>\d+),(?<col>\d+)\): error (?<code>[A-Z]+\d+): (?<msg>.*?)(?: \[.*\])?\s*$/gm;
+
+export function parseCompilerErrors(output) {
+  return [...String(output).matchAll(MSBUILD_ERROR)].map((m) => ({
+    file: m.groups.file.trim(), line: Number(m.groups.line), code: m.groups.code, message: m.groups.msg.trim(),
+  }));
+}
+
+/**
+ * An error inside a patched span names its mutant; one elsewhere in a patched file
+ * (an `out` variable the switch left unassigned) names every mutant of that file.
+ */
+export function blame(errors, patched) {
+  const blamed = new Set();
+  const unmapped = [];
+  for (const err of errors) {
+    const file = patched.find((p) => samePath(p.abs, err.file));
+    if (!file) { unmapped.push(err); continue; }
+    const inSpan = [...file.spans].find(([, s]) => err.line >= s.from && err.line <= s.to);
+    if (inSpan) blamed.add(inSpan[0]);
+    else for (const id of file.spans.keys()) blamed.add(id);
+  }
+  return { blamed: [...blamed], unmapped };
+}
+
+const samePath = (a, b) => a.replace(/\\/g, '/').toLowerCase() === b.replace(/\\/g, '/').toLowerCase();

package/src/lib/mutation/snapshot.js

@@ -0,0 +1,69 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+
+export const md5Of = (bytes) => createHash('md5').update(bytes).digest('hex');
+export const md5OfFile = (abs) => md5Of(readFileSync(abs));
+
+/**
+ * Copies of the original bytes, kept outside the working tree, plus a journal
+ * that survives the process: a run killed halfway is undone by the next
+ * `--restore` from the journal alone.
+ */
+export function openSnapshot({ dir, root, files, runId }) {
+  mkdirSync(dir, { recursive: true });
+  const entries = files.map((file, index) => {
+    const abs = join(root, file);
+    const bytes = readFileSync(abs);
+    const backup = join(dir, `${index}.bak`);
+    writeFileSync(backup, bytes);
+    return { file, md5: md5Of(bytes), backup, created: false };
+  });
+  const snapshot = { runId, root, dir, entries, generated: [], state: 'open' };
+  writeJournal(snapshot);
+  return snapshot;
+}
+
+export function trackGenerated(snapshot, file) {
+  if (!snapshot.generated.includes(file)) snapshot.generated.push(file);
+  writeJournal(snapshot);
+}
+
+export function writeJournal(snapshot) {
+  writeFileSync(join(snapshot.dir, 'journal.json'), JSON.stringify(snapshot, null, 2));
+}
+
+export function readJournal(dir) {
+  const path = join(dir, 'journal.json');
+  return existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) : null;
+}
+
+/**
+ * Writes the original bytes back — a fresh write, so the file is NEWER than
+ * any binary built from a mutant. Restoring the old mtime would let the build
+ * consider the mutant binary up to date and never recompile the source.
+ */
+export function restoreSnapshot(snapshot, { rewrite = true } = {}) {
+  const report = [];
+  for (const entry of snapshot.entries) {
+    const abs = join(snapshot.root, entry.file);
+    const before = existsSync(abs) ? md5OfFile(abs) : null;
+    if (rewrite || before !== entry.md5) {
+      mkdirSync(dirname(abs), { recursive: true });
+      writeFileSync(abs, readFileSync(entry.backup));
+    }
+    const after = md5OfFile(abs);
+    report.push({ file: entry.file, md5Original: entry.md5, md5Before: before, md5After: after, ok: after === entry.md5 });
+  }
+  for (const file of snapshot.generated) {
+    const abs = join(snapshot.root, file);
+    if (existsSync(abs)) unlinkSync(abs);
+  }
+  snapshot.state = report.every((r) => r.ok) ? 'restored' : 'restore-failed';
+  writeJournal(snapshot);
+  return report;
+}
+
+export function discardSnapshot(snapshot) {
+  rmSync(snapshot.dir, { recursive: true, force: true });
+}

package/src/lib/mutation/subset.js

@@ -0,0 +1,75 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { csharpClasses } from '../tasks/dotnet-test-introspection.js';
+import { relatedCommand } from './commands.js';
+
+const SKIP_DIRS = new Set(['bin', 'obj', 'node_modules', '.git', 'worktrees', 'TestResults']);
+const SAFE_CLASS = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const MIN_TYPE_LENGTH = 4;
+
+const posix = (p) => p.replace(/\\/g, '/');
+
+function walkCs(dir, out = []) {
+  let entries = [];
+  try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return out; }
+  for (const e of entries) {
+    if (e.isDirectory()) {
+      if (!SKIP_DIRS.has(e.name)) walkCs(join(dir, e.name), out);
+    } else if (e.name.endsWith('.cs')) {
+      out.push(join(dir, e.name));
+    }
+  }
+  return out;
+}
+
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/**
+ * The tests to run FIRST, chosen by the tool: files the feature changed, and files naming a
+ * type the mutated files declare. A mutant the subset does not kill goes to the whole suite.
+ */
+export function dotnetSubset({ root, testProjectDirs, mutatedFiles, changed = [] }) {
+  const changedSet = new Set(changed.map(posix));
+  const mutatedTypes = new Set();
+  for (const file of mutatedFiles) {
+    for (const t of csharpClasses(resolve(root, file)).types) if (t.length >= MIN_TYPE_LENGTH) mutatedTypes.add(t);
+  }
+  const mention = mutatedTypes.size > 0
+    ? new RegExp(`\\b(?:${[...mutatedTypes].map(escapeRe).join('|')})\\b`) : null;
+
+  const byChange = new Set();
+  const byMention = new Set();
+  const classes = new Set();
+  for (const dir of testProjectDirs) {
+    for (const abs of walkCs(resolve(root, dir))) {
+      const info = csharpClasses(abs);
+      if (!info.scannable || !info.hasTestAttribute || info.names.length === 0) continue;
+      const rel = posix(relative(root, abs));
+      const viaChange = changedSet.has(rel);
+      const viaMention = !viaChange && mention !== null && mention.test(readFileSync(abs, 'utf8'));
+      if (!viaChange && !viaMention) continue;
+      (viaChange ? byChange : byMention).add(rel);
+      for (const name of info.names) classes.add(name);
+    }
+  }
+  const unsafe = [...classes].find((c) => !SAFE_CLASS.test(c));
+  if (unsafe) return { usable: false, reason: `nome de classe "${unsafe}" não é seguro num filtro` };
+  if (classes.size === 0) return { usable: false, reason: 'nenhum arquivo de teste alterado pela feature nem citando os tipos mutados' };
+  return {
+    usable: true,
+    classes: [...classes].sort(),
+    filter: [...classes].sort().map((c) => `FullyQualifiedName~${c}`).join('|'),
+    files: { changed: [...byChange].sort(), mentions: [...byMention].sort() },
+  };
+}
+
+export function jsSubset({ runner, command, root, mutatedFiles }) {
+  const files = mutatedFiles.filter((f) => existsSync(resolve(root, f)) && statSync(resolve(root, f)).isFile());
+  const cmd = relatedCommand(runner, command, files);
+  if (cmd === null) return { usable: false, reason: `runner "${runner}" sem seleção por arquivo relacionado neste formato de comando` };
+  return { usable: true, command: cmd, files: { related: files } };
+}
+
+export function testProjectDirsOf(root, csprojs) {
+  return [...new Set(csprojs.map((c) => posix(relative(root, dirname(resolve(root, c))))))];
+}

package/src/lib/mutation/trx.js

@@ -0,0 +1,51 @@
+const ENTITIES = { '&lt;': '<', '&gt;': '>', '&amp;': '&', '&quot;': '"', '&apos;': "'" };
+
+export function decodeXml(text) {
+  return text
+    .replace(/&(?:lt|gt|amp|quot|apos);/g, (m) => ENTITIES[m])
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(parseInt(hex, 16)))
+    .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number(dec)));
+}
+
+const attr = (attrs, name) => new RegExp(`\\b${name}="([^"]*)"`).exec(attrs)?.[1] ?? null;
+const count = (attrs, name) => Number(attr(attrs, name) ?? 0);
+
+/**
+ * What a VSTest TRX says about a run: the counters, and for every failed test
+ * its name and the FIRST message line — the literal reason a mutation report
+ * quotes. Linear over the text: a full suite writes several MB.
+ */
+export function parseTrx(xml) {
+  const counters = /<Counters\b([^>]*)\/?>/.exec(xml)?.[1] ?? null;
+  const summary = /<ResultSummary\b([^>]*)>/.exec(xml)?.[1] ?? '';
+  const failedTests = [];
+  const tag = /<UnitTestResult\b([^>]*?)(\/?)>/g;
+  for (let m = tag.exec(xml); m; m = tag.exec(xml)) {
+    if (attr(m[1], 'outcome') !== 'Failed') continue;
+    let message = '';
+    if (m[2] !== '/') {
+      const close = xml.indexOf('</UnitTestResult>', tag.lastIndex);
+      const body = xml.slice(tag.lastIndex, close === -1 ? undefined : close);
+      const raw = /<Message>([\s\S]*?)<\/Message>/.exec(body)?.[1] ?? '';
+      message = decodeXml(raw.replace(/^<!\[CDATA\[|\]\]>$/g, '')).trim();
+    }
+    failedTests.push({ name: decodeXml(attr(m[1], 'testName') ?? '?'), message });
+  }
+  return {
+    parsed: counters !== null,
+    total: counters ? count(counters, 'total') : 0,
+    executed: counters ? count(counters, 'executed') : 0,
+    passed: counters ? count(counters, 'passed') : 0,
+    failed: counters ? count(counters, 'failed') : failedTests.length,
+    aborted: counters ? count(counters, 'aborted') + count(counters, 'timeout') : 0,
+    runOutcome: attr(summary, 'outcome'),
+    failedTests,
+  };
+}
+
+export const methodOf = (testName) => String(testName).replace(/\s*\(.*$/s, '').trim();
+
+export function firstLines(message, max = 2, width = 240) {
+  const lines = String(message).split(/\r?\n/).map((l) => l.trim()).filter(Boolean).slice(0, max).join(' ⏎ ');
+  return lines.length > width ? `${lines.slice(0, width)}…` : lines;
+}