@polymorphism-tech/morph-spec 9.8.0 → 10.1.1

package/src/lib/mutation/dotnet-introspection.js

@@ -1,281 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from 'fs';
-import { dirname, join, resolve } from 'path';
-
-import { isInside } from '../tasks/test-runner.js';
-import { jsoncToJson } from '../../../framework/hooks/shared/comment-stripper.js';
-
-const MTP_RUNNER = 'Microsoft.Testing.Platform';
-const TYPE_HEADER = /\b(?:class|struct|record|interface)\b/;
-// `@` = verbatim identifier, `\` = unicode escape.
-const NAME_START = '[\\p{L}\\p{Nl}_@\\\\]';
-// TRIPWIRE with NO context rule: any exclusion based on what precedes the keyword can be
-// forged by a comment or exposed string. The quote in the lookahead makes every keyword
-// the blanked code counts also counted in the raw text, at the same offset.
-const TYPE_KEYWORD = new RegExp(`\\b(?:record\\s+(?:class|struct)|class|record|struct|interface)\\b(?=\\s*(?:${NAME_START}|["']|\\/[/*]|#))`, 'gu');
-const TYPE_DECL = new RegExp(`(?:^|[;{}\\]\\n])[ \\t]*(?:\\[[^\\]\\n]*\\][ \\t]*)*(?:(?:public|internal|private|protected|sealed|static|partial|abstract|unsafe|file|new|readonly|ref)\\s+)*(record\\s+(?:class|struct)|class|record|struct|interface)\\s+(${NAME_START}[^\\s:<({;,=]*)`, 'gu');
-const IDENT = '[\\p{L}_][\\p{L}\\p{N}_]*';
-const QUALIFIER = `(?:${IDENT}\\s*(?:\\.|::)\\s*)*`;
-const ATTRIBUTE_ARGS = '(?:\\((?:[^()\\]]|\\([^()\\]]*\\))*\\))?';
-const OTHER_ATTRIBUTE = `${QUALIFIER}${IDENT}\\s*${ATTRIBUTE_ARGS}`;
-const TEST_ATTRIBUTE_NAME = '(?:Fact|Theory|Test|TestMethod|DataTestMethod|TestCase|TestCaseSource)(?:Attribute)?';
-// A false POSITIVE is the unsafe side (a helper taken for a test file hides the tests that
-// use it), so the whole name must sit in an attribute section that CLOSES: a C# 12
-// collection such as `[\n Env.Test,\n];` must not match. Residual cases: csharpClasses.
-export const CS_TEST_ATTRIBUTE = new RegExp(
-  '(?:^|[;{}\\]]|\\*\\/)[ \\t]*\\['
-  + `\\s*(?:${IDENT}\\s*:(?!:)\\s*)?`
-  + `(?:${OTHER_ATTRIBUTE}\\s*,\\s*)*`
-  + `${QUALIFIER}${TEST_ATTRIBUTE_NAME}(?![\\p{L}\\p{N}_])\\s*${ATTRIBUTE_ARGS}`
-  + `(?:\\s*,\\s*${OTHER_ATTRIBUTE})*`
-  + '\\s*\\]\\s*(?:[\\[\\p{L}_@/#]|(?![\\s\\S]))',
-  'mu',
-);
-
-// Roslyn reads CR/NEL/LS/PS as new-lines and U+001A as whitespace; JS `\s` misses NEL
-// and U+001A, which hid `class<NEL>Name`. Mapped 1:1 so offsets stay aligned with the code.
-const readText = (path) => {
-  try { return readFileSync(path, 'utf8').replace(/\x1A/g, ' ').replace(/^\uFEFF/, '').replace(/[\r\u0085\u2028\u2029]/g, '\n'); } catch { return null; }
-};
-
-function nearestProjectFile(fileAbs, rootAbs, projectName) {
-  for (let dir = dirname(fileAbs); isInside(dir, rootAbs); dir = dirname(dir)) {
-    let names = [];
-    try { names = readdirSync(dir).filter((n) => projectName.test(n)).sort(); } catch { /* unreadable dir */ }
-    if (names.length > 0) return join(dir, names[0]);
-    if (dirname(dir) === dir) break;
-  }
-  return null;
-}
-
-export function nearestProjectOf(fileAbs, rootAbs) {
-  return nearestProjectFile(fileAbs, rootAbs, /\.(?:cs|fs|vb)proj$/i);
-}
-
-const NON_CSHARP_SOURCE = /\.(?:razor|cshtml|fs|fsi|fsx|vb)$/i;
-
-/** No type scan, hence no class selector, for these. */
-export const isNonCSharpSource = (path) => NON_CSHARP_SOURCE.test(String(path));
-
-export const isDotnetSource = (path) => /\.cs$/i.test(String(path)) || isNonCSharpSource(path);
-
-/**
- * Nearest global.json walking up from the CWD, as the SDK resolves it (never from the
- * `.sln` argument). null when one exists but cannot be read — never a guess.
- */
-export function dotnetTestMode(absCwd) {
-  for (let dir = resolve(absCwd); ; dir = dirname(dir)) {
-    const file = join(dir, 'global.json');
-    if (existsSync(file)) {
-      try {
-        const parsed = JSON.parse(jsoncToJson(readFileSync(file, 'utf8')));
-        return parsed?.test?.runner === MTP_RUNNER ? 'mtp' : 'vstest';
-      } catch {
-        return null;
-      }
-    }
-    if (dirname(dir) === dir) return 'vstest';
-  }
-}
-
-const lineEnd = (text, i) => { const e = text.indexOf('\n', i); return e < 0 ? text.length : e; };
-
-function closeOnLine(text, start, quote) {
-  for (let j = start + 1; j < text.length && text[j] !== '\n'; j++) {
-    if (text[j] === '\\') j++;
-    else if (text[j] === quote) return j + 1;
-  }
-  return -1;
-}
-
-// A `"` inside a hole (`$"{d["k"]}"`) ends the literal as the scanner reads it,
-// leaving the hole open. `{{`/`}}` outside a hole are escapes.
-function holeLeftOpen(content) {
-  let depth = 0;
-  for (let k = 0; k < content.length; k++) {
-    const c = content[k];
-    if (depth === 0 && (c === '{' || c === '}') && content[k + 1] === c) { k++; continue; }
-    if (c === '{') depth++;
-    else if (c === '}' && depth > 0) depth--;
-  }
-  return depth > 0;
-}
-
-/**
- * Comments, preprocessor lines and literals blanked, length and newlines kept; null when
- * a literal never ends or an interpolation hole is cut. A heuristic lexer that CAN misread:
- * csharpClasses never trusts it alone (it checks against the raw text).
- */
-export function blankCSharpLiterals(text) {
-  const out = text.split('');
-  const blank = (from, to) => { for (let k = from; k < to; k++) if (out[k] !== '\n') out[k] = ' '; };
-  for (let i = 0; i < text.length;) {
-    const c = text[i];
-    let end = -1;
-    if (c === '#' && /^[ \t]*$/.test(text.slice(text.lastIndexOf('\n', i - 1) + 1, i))) {
-      end = lineEnd(text, i);
-    } else if (c === '/' && text[i + 1] === '/') {
-      end = lineEnd(text, i);
-    } else if (c === '/' && text[i + 1] === '*') {
-      const close = text.indexOf('*/', i + 2);
-      if (close < 0) return null;
-      end = close + 2;
-    } else if (c === '"' && (text[i - 1] === '@' || (text[i - 1] === '$' && text[i - 2] === '@'))) {
-      let j = i + 1;
-      while (j < text.length && !(text[j] === '"' && text[j + 1] !== '"')) j += text[j] === '"' ? 2 : 1;
-      if (j >= text.length) return null;
-      end = j + 1;
-      const interpolated = text[i - 1] === '$' || text[i - 2] === '$';
-      if (interpolated && holeLeftOpen(text.slice(i + 1, end - 1))) return null;
-    } else if (c === '"') {
-      let quotes = 0;
-      while (text[i + quotes] === '"') quotes++;
-      if (quotes >= 3) {
-        const close = text.indexOf('"'.repeat(quotes), i + quotes);
-        if (close < 0) return null;
-        end = close + quotes;
-      } else {
-        end = closeOnLine(text, i, '"');
-        if (end < 0) return null;
-        if (text[i - 1] === '$' && holeLeftOpen(text.slice(i + 1, end - 1))) return null;
-      }
-    } else if (c === "'") {
-      end = closeOnLine(text, i, "'");
-      if (end < 0) return null;
-    }
-    if (end < 0) { i++; continue; }
-    blank(i, end);
-    i = end;
-  }
-  return out.join('');
-}
-
-const typeKeywordCount = (text) => [...text.matchAll(TYPE_KEYWORD)].length;
-
-/**
- * The types of a C# file, read FAIL-SAFE.
- *
- * `types` lists the BARE name of EVERY type declaration (class, record, struct,
- * interface) at ANY depth, in source order, with no namespace. A selection built
- * from these names is namespace-free (`--filter-class "*T*"`, measured, or the
- * substring `FullyQualifiedName~T`): any namespace, `Outer+Inner`, `Name`1` — a
- * selection that can only run MORE tests than the file's, never fewer.
- *
- * THE GUARANTEE (what `scannable: true` means), and why it holds:
- *   every type-keyword token of the RAW text is a declaration in `types`.
- * - R = keyword tokens of the raw text (TYPE_KEYWORD, no context rule); C = the
- *   same on the blanked code; D = the declarations named (TYPE_DECL on the code).
- *   `scannable` requires |R| = |D| and |C| = |D|. By construction D ⊆ C ⊆ R as
- *   sets of offsets: blanking keeps length and only replaces characters by spaces,
- *   a blanked region starts at `"` `'` `/` `#` and ends at `"` `'` `*` `/` or a
- *   line end (never inside an identifier), and the raw lookahead accepts every
- *   character the code lookahead can be looking past (a name, a comment, `#`, a
- *   quote). So |R| = |D| forces R = D. A real declaration's keyword is always in R
- *   (it is followed by its name, or by a comment/directive before the name) —
- *   UNDER ONE ASSUMPTION: every character Roslyn reads as whitespace or a new-line
- *   between a keyword and its name is whitespace to JS `\s` once readText has run.
- *   Roslyn's whitespace is Unicode Zs, TAB, VT, FF and U+001A; its new-lines are
- *   CR, LF, NEL, LS and PS. JS `\s` already covers Zs, TAB, VT, FF and LF, and
- *   readText maps CR/NEL/LS/PS to `\n` and U+001A to a space. A separator outside
- *   that shared set would hide a declaration from R; none is known, and that is a
- *   statement about the two lexers as read, not a proof.
- *   Hence: a declaration swallowed by ANY misread — `"/*"` taken for a comment
- *   opener, a quote inside an interpolation hole, a char literal — is still in R
- *   and cannot be compensated by anything (a fake the code exposes is in R too).
- * - `abstract` lists the abstract types: their tests run under the names of DERIVED
- *   classes, possibly in other files.
- * - `hasTestAttribute`: a test attribute (CS_TEST_ATTRIBUTE: a whole name inside an
- *   attribute section) is present in the blanked code (a file without one is a
- *   helper/fake/fixture: the tests using it are elsewhere).
- * - kept fail-safes: braces balance and blankCSharpLiterals returning null → unscannable.
- *
- * NOT guaranteed (stated, not hidden):
- * - completeness: keyword-shaped text in a real comment or string (`// the
- *   class under test`), a constraint keyword followed by a name-shaped token
- *   (`where T : class where …`, `: class // note`), `record with`, a directive
- *   splitting a name — all make the file unscannable;
- * - which scope a type was read in;
- * - a NON-abstract class whose tests are inherited by derived classes declared in
- *   OTHER files: the touched class runs; the derived copies only if their names
- *   contain it;
- * - a test attribute reached through an alias (`using F = Xunit.FactAttribute; [F]`)
- *   or a custom one (`[SkippableFact]`) is not seen: the file counts as a helper and
- *   it is left out of a selection;
- * - `hasTestAttribute` is still a heuristic, and ITS false positive is the unsafe
- *   side. The section must close; what still matches in a
- *   helper — probed — is a LIST PATTERN opening a line (or after `;` `{` `}` `]`)
- *   whose element is named exactly `Test`/`Fact`/… (qualified or not) and whose `]`
- *   is followed by a combinator: `[Env.Test] or [Env.Dev] => true`. Such a helper is
- *   taken for a test file. (`[Env.Test] => 1` does not match: `=` starts no declaration.)
- *
- * @param {string} csFileAbs
- * @returns {{ names: string[], types: string[], abstract: string[], hasTestClass: boolean, hasTestAttribute: boolean, scannable: boolean, why: string|null }}
- *   `names`: top-level `class` names (classNamesOf). `abstract`: the abstract
- *   types. `hasTestClass`: some plain `class` is declared (records, structs and
- *   interfaces hold no tests). `hasTestAttribute`: see above. `why`: the reason
- *   when `scannable` is false.
- */
-export function csharpClasses(csFileAbs) {
-  const unscannable = (why) => ({ names: [], types: [], abstract: [], hasTestClass: false, hasTestAttribute: false, scannable: false, why });
-  const text = readText(csFileAbs);
-  if (text === null) return { names: [], types: [], abstract: [], hasTestClass: false, hasTestAttribute: false, scannable: true, why: null };
-  const code = blankCSharpLiterals(text);
-  if (code === null) return unscannable('a literal or comment never ends, or an interpolation hole is cut by an inner quote');
-
-  const decls = [...code.matchAll(TYPE_DECL)].map((m) => ({
-    at: m.index + m[0].length - m[2].length,
-    kind: m[1].split(/\s+/)[0],
-    name: m[2],
-    abstract: /\babstract\b/.test(m[0]),
-    gap: m[0].slice(0, m[0].length - m[2].length).match(/\s*$/)[0].length,
-  }));
-  // A preprocessor line between a keyword and its name (`class\n#if X\nA\n#else\nB…`)
-  // makes the compiled name depend on a symbol this scan cannot see. Blanking keeps
-  // length, so the raw text at the same offsets shows the directive.
-  const split = decls.find((d) => /(^|\n)[ \t]*#/.test(text.slice(d.at - d.gap, d.at)));
-  if (split) return unscannable(`a preprocessor directive stands between a type keyword and the name "${split.name}"`);
-  // The raw text is the lexer-independent truth about how many type keywords the file
-  // carries (the JSDoc explains why equal counts mean equal sets).
-  const rawKeywords = typeKeywordCount(text);
-  if (rawKeywords !== decls.length) {
-    return unscannable(`${rawKeywords} type keyword(s) in the file but ${decls.length} declaration(s) recognised`);
-  }
-  const codeKeywords = typeKeywordCount(code);
-  if (codeKeywords !== decls.length) {
-    return unscannable(`${codeKeywords} type keyword(s) in the code but ${decls.length} declaration(s) recognised`);
-  }
-
-  const names = [];
-  const types = [];
-  const abstractTypes = [];
-  const scopes = [];
-  let hasTestClass = false;
-  let header = 0;
-  for (let i = 0, d = 0; i < code.length; i++) {
-    for (; d < decls.length && decls[d].at === i; d++) {
-      types.push(decls[d].name);
-      if (decls[d].abstract) abstractTypes.push(decls[d].name);
-      if (decls[d].kind === 'class') {
-        hasTestClass = true;
-        if (!scopes.some((s) => s.type)) names.push(decls[d].name);
-      }
-    }
-    const c = code[i];
-    if (c === '{') {
-      scopes.push({ type: TYPE_HEADER.test(code.slice(header, i)) });
-    } else if (c === '}' && scopes.pop() === undefined) {
-      return unscannable('a `}` closes nothing');
-    }
-    if (c === '{' || c === '}' || c === ';') header = i + 1;
-  }
-  if (scopes.length > 0) return unscannable('braces left open at end of file');
-  return {
-    names: [...new Set(names)],
-    types: [...new Set(types)],
-    abstract: [...new Set(abstractTypes)],
-    hasTestClass,
-    hasTestAttribute: CS_TEST_ATTRIBUTE.test(code),
-    scannable: true,
-    why: null,
-  };
-}
-

package/src/lib/mutation/manifest.js

@@ -1,144 +0,0 @@
-import { posix, win32 } from 'node:path';
-
-export const MUTANT_ID = /^[A-Za-z][A-Za-z0-9_-]{0,31}$/;
-export const MODES = ['schemata', 'rebuild'];
-export const BACKSLASH_TOKEN = '{{BS}}';
-export const MAX_MUTANTS = 3;
-
-const expandBackslash = (s) => (typeof s === 'string' ? s.split(BACKSLASH_TOKEN).join(String.fromCharCode(92)) : s);
-
-export class ManifestError extends Error {
-  constructor(problems) {
-    super(`manifesto de mutantes inválido:\n${problems.map((p) => `  - ${p}`).join('\n')}`);
-    this.name = 'ManifestError';
-    this.problems = problems;
-  }
-}
-
-export function eolOf(text) {
-  return text.includes('\r\n') ? '\r\n' : '\n';
-}
-
-const toEol = (s, eol) => s.replace(/\r?\n/g, eol);
-
-function lineBounds(text, line) {
-  let start = 0;
-  for (let n = 1; n < line; n++) {
-    const nl = text.indexOf('\n', start);
-    if (nl === -1) return null;
-    start = nl + 1;
-  }
-  const nl = text.indexOf('\n', start);
-  return { start, end: nl === -1 ? text.length : nl };
-}
-
-/**
- * Where `find` begins: it must start on `line` and occur there exactly once,
- * so the `arquivo:linha` of the report is a fact the tool derived, not typed.
- */
-export function locate(text, { line, find }) {
-  const bounds = lineBounds(text, line);
-  if (!bounds) return { error: `o arquivo tem menos de ${line} linhas` };
-  const needle = toEol(find, eolOf(text));
-  const at = text.indexOf(needle, bounds.start);
-  if (at === -1) return { error: `\`find\` não aparece a partir da linha ${line}` };
-  if (at > bounds.end) {
-    const first = text.slice(0, at).split('\n').length;
-    return { error: `\`find\` começa na linha ${first}, não na ${line}` };
-  }
-  const again = text.indexOf(needle, at + 1);
-  if (again !== -1 && again <= bounds.end) {
-    return { error: `\`find\` aparece mais de uma vez na linha ${line}: estenda-o até ficar único` };
-  }
-  return { start: at, end: at + needle.length, needle };
-}
-
-export function validateManifest(manifest, { fileExists } = {}) {
-  const problems = [];
-  const list = manifest?.mutants;
-  if (!Array.isArray(list) || list.length === 0) {
-    throw new ManifestError(['`mutants` precisa ser um array com ao menos um mutante']);
-  }
-  if (list.length > MAX_MUTANTS) {
-    throw new ManifestError([`no máximo ${MAX_MUTANTS} mutantes por rodada: escolha as linhas de guarda ou regra que um UC exige`]);
-  }
-  const seen = new Set();
-  const mutants = list.map((raw, index) => {
-    const at = `mutants[${index}]${typeof raw?.id === 'string' ? ` (${raw.id})` : ''}`;
-    const m = raw ?? {};
-    if (typeof m.id !== 'string' || !MUTANT_ID.test(m.id)) problems.push(`${at}: \`id\` inválido (letra + letras/dígitos/_/-, até 32)`);
-    else if (seen.has(m.id)) problems.push(`${at}: \`id\` repetido`);
-    else seen.add(m.id);
-    if (typeof m.file !== 'string' || m.file === '') problems.push(`${at}: \`file\` ausente`);
-    else if (posix.isAbsolute(m.file) || win32.isAbsolute(m.file) || m.file.split(/[\\/]/).includes('..')) problems.push(`${at}: \`file\` tem de ser relativo à raiz do projeto, sem \`..\``);
-    else if (fileExists && !fileExists(m.file)) problems.push(`${at}: \`file\` não existe: ${m.file}`);
-    if (!Number.isInteger(m.line) || m.line < 1) problems.push(`${at}: \`line\` tem de ser inteiro >= 1`);
-    if (typeof m.find !== 'string' || m.find === '') problems.push(`${at}: \`find\` ausente`);
-    if (typeof m.replace !== 'string') problems.push(`${at}: \`replace\` ausente (use string vazia para apagar)`);
-    else if (m.replace === m.find) problems.push(`${at}: \`replace\` igual a \`find\` não é mutação`);
-    if (m.mode !== undefined && !MODES.includes(m.mode)) problems.push(`${at}: \`mode\` tem de ser ${MODES.join(' | ')}`);
-    if (typeof m.expect !== 'string' || m.expect.trim() === '') problems.push(`${at}: \`expect\` ausente — diga qual teste deve falhar e por quê; sem isso o mutante pode ser equivalente`);
-    return {
-      id: m.id, file: typeof m.file === 'string' ? m.file.replace(/\\/g, '/') : m.file,
-      line: m.line, find: expandBackslash(m.find), replace: expandBackslash(m.replace), mode: m.mode ?? null,
-      note: typeof m.note === 'string' ? m.note : null,
-      expect: typeof m.expect === 'string' ? m.expect : null,
-    };
-  });
-  if (problems.length > 0) throw new ManifestError(problems);
-  return mutants;
-}
-
-/**
- * Resolves every mutant against the file text and refuses overlaps: two
- * regions of one file inside each other cannot both be a switch in one build.
- */
-export function resolveRegions(mutants, readText) {
-  const problems = [];
-  const byFile = new Map();
-  for (const m of mutants) {
-    const text = readText(m.file);
-    if (text === null) { problems.push(`${m.id}: não consegui ler ${m.file}`); continue; }
-    const at = locate(text, m);
-    if (at.error) { problems.push(`${m.id}: ${at.error}`); continue; }
-    const eol = eolOf(text);
-    const region = {
-      ...m, start: at.start, end: at.end, eol,
-      findText: at.needle, replaceText: toEol(m.replace, eol),
-    };
-    if (!byFile.has(m.file)) byFile.set(m.file, []);
-    byFile.get(m.file).push(region);
-  }
-  for (const regions of byFile.values()) {
-    regions.sort((a, b) => a.start - b.start);
-    for (let i = 1; i < regions.length; i++) {
-      if (regions[i].start < regions[i - 1].end) {
-        problems.push(`${regions[i].id} e ${regions[i - 1].id} se sobrepõem em ${regions[i].file}: rode-os em manifestos separados`);
-      }
-    }
-  }
-  if (problems.length > 0) throw new ManifestError(problems);
-  return mutants.map((m) => [...byFile.values()].flat().find((r) => r.id === m.id));
-}
-
-export function applyRegions(text, regions, produce) {
-  let out = '';
-  let cursor = 0;
-  const spans = new Map();
-  for (const region of [...regions].sort((a, b) => a.start - b.start)) {
-    out += text.slice(cursor, region.start);
-    const from = out.split('\n').length;
-    out += produce(region);
-    spans.set(region.id, { from, to: out.split('\n').length });
-    cursor = region.end;
-  }
-  return { text: out + text.slice(cursor), spans };
-}
-
-export function diffOf(m, limit = 160) {
-  const one = (s) => {
-    const flat = s.replace(/\r?\n\s*/g, ' ').replace(/\|/g, '\\|');
-    return flat.length > limit ? `${flat.slice(0, limit)}…` : flat;
-  };
-  return `\`- ${one(m.find)}\` / \`+ ${one(m.replace)}\``;
-}

package/src/lib/mutation/plan.js

@@ -1,44 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { isInside } from '../tasks/test-runner.js';
-import { isDotnetSource } from './dotnet-introspection.js';
-import { resolveRegions, validateManifest } from './manifest.js';
-
-const JS_RUNNERS = new Set(['vitest', 'jest', 'node-test']);
-
-export function loadPlan({ root, planPath }) {
-  const manifest = JSON.parse(readFileSync(planPath, 'utf8').replace(/^/, ''));
-  const mutants = validateManifest(manifest, { fileExists: (f) => existsSync(join(root, f)) });
-  return resolveRegions(mutants, (f) => {
-    try { return readFileSync(join(root, f), 'utf8'); } catch { return null; }
-  });
-}
-
-function ownersOf(file, nodes, root) {
-  if (isDotnetSource(file)) return nodes.filter((n) => n.runner === 'dotnet');
-  const abs = resolve(root, file);
-  return nodes
-    .filter((n) => JS_RUNNERS.has(n.runner) && isInside(abs, resolve(root, n.cwd || '.')))
-    .sort((a, b) => resolve(root, b.cwd || '.').length - resolve(root, a.cwd || '.').length);
-}
-
-// An `e2e: true` suite tests the running compose stack, which mutate never
-// rebuilds: it is picked only when no other suite owns the file, and the caller refuses.
-export function pickNode(file, nodes, root) {
-  const owners = ownersOf(file, nodes, root);
-  return owners.find((n) => !n.e2e) ?? owners[0] ?? null;
-}
-
-export function groupByNode(regions, nodes, root) {
-  const groups = new Map();
-  const orphans = [];
-  const stackOnly = [];
-  for (const region of regions) {
-    const node = pickNode(region.file, nodes, root);
-    if (!node) { orphans.push(region); continue; }
-    if (node.e2e) { stackOnly.push({ region, node }); continue; }
-    if (!groups.has(node.id)) groups.set(node.id, { node, regions: [] });
-    groups.get(node.id).regions.push(region);
-  }
-  return { groups: [...groups.values()], orphans, stackOnly };
-}

package/src/lib/mutation/report.js

@@ -1,68 +0,0 @@
-const cell = (s) => String(s ?? '').replace(/\r?\n/g, ' ').replace(/\|/g, '\\|');
-const short = (md5) => (md5 ? md5.slice(0, 12) : '—');
-const seconds = (ms) => `${(ms / 1000).toFixed(1)} s`;
-
-function countCell(m) {
-  const scope = m.scope === 'subset' ? 'subconjunto' : 'suíte inteira';
-  switch (m.verdict) {
-    case 'killed': return m.scope === 'subset' ? `≥${m.killers} de ${m.executed} (${scope})` : `${m.killers} de ${m.executed ?? '?'} (${scope})`;
-    case 'survived': return `**0 de ${m.executed ?? '?'} (SOBREVIVEU, ${scope})**`;
-    case 'build-error': return '— (o mutante não compila: não é morte)';
-    default: return '— (inconclusivo: não conta como morte nem como sobrevivência)';
-  }
-}
-
-function reasonCell(m) {
-  if (m.verdict === 'survived') return m.reason || `nenhum teste falhou ${m.scope === 'subset' ? 'no subconjunto' : 'na suíte inteira'}${m.expect ? ` — esperado: ${m.expect}` : ''}`;
-  const how = m.demoted ? ` [rebuild: ${m.demoted}]` : '';
-  return `${m.reason || '—'}${how}`;
-}
-
-const BINARY = {
-  md5: 'DLL do rebuild final idêntica (md5) à DLL construída da árvore limpa antes de qualquer mutante',
-  rebuilt: 'DLL recompilada DEPOIS da restauração e sem a chave de schemata, mas com md5 diferente da baseline — o build não é determinístico neste projeto, então o conteúdo não se compara',
-  unavailable: 'sem etapa de build neste runner: nada a provar sobre binário',
-  unlocated: 'ATENÇÃO — o build não informou a DLL dos projetos mutados, então o binário final NÃO pôde ser provado',
-  mismatch: 'ATENÇÃO — a DLL do rebuild final NÃO bate com a baseline e ainda carrega a chave de schemata',
-};
-
-export function renderSection(result, { head = null, date = null, subset = null, note = null } = {}) {
-  const lines = ['## Mutações', ''];
-  const { method } = result;
-  const where = subset?.usable
-    ? (subset.classes
-      ? `${subset.classes.length} classe(s) de teste (${subset.files?.changed?.length ?? 0} alterada(s) pela feature, ${subset.files?.mentions?.length ?? 0} citando os tipos mutados)`
-      : `${subset.files?.related?.length ?? 0} arquivo(s) de teste relacionados`)
-    : (subset?.reason ?? 'nenhum');
-  lines.push(`**Método:** \`morph-spec mutate\`${head ? ` sobre ${head.slice(0, 8)}` : ''}${date ? ` em ${date}` : ''}.`);
-  lines.push(`- ${method.schemata} mutante(s) por chave em UM build (schemata), ${method.rebuild} por rebuild real${(method.jobs ?? 1) > 1 ? `; rodadas de escopo rápido em ${method.jobs} workers` : ''}.`);
-  lines.push(`- Escopo rápido: ${method.subset.live ? where : `desligado (${method.subset.note ?? subset?.reason ?? 'sem subconjunto'})`}.`);
-  lines.push('- Morto = falha nova (ausente na rodada-base do mesmo escopo). Com subconjunto, a decisão fica nele: sobrevivente não é refeito na suíte inteira.');
-  if (result.baseline.subset) lines.push(`- Rodada-base do subconjunto: ${result.baseline.subset.executed} executados, ${result.baseline.subset.failed} falhando.`);
-  if (result.baseline.full) lines.push(`- Rodada-base da suíte inteira: ${result.baseline.full.executed} executados, ${result.baseline.full.failed} falhando.`);
-  if (note) lines.push(`- ${note}`);
-  lines.push('');
-  lines.push('| # | Arquivo:linha | Mutação (diff) | md5 antes | md5 depois | Testes derrubados | Motivo da falha |');
-  lines.push('|---|---|---|---|---|---|---|');
-  for (const m of result.mutants) {
-    lines.push(`| ${m.id} | ${cell(`${m.file}:${m.line}`)} | ${m.diff} | ${short(m.md5Before)} | ${short(m.md5After)} | ${cell(countCell(m))} | ${cell(reasonCell(m))} |`);
-  }
-  lines.push('');
-  const r = result.restore;
-  const bad = r.files.filter((f) => !f.ok).map((f) => f.file);
-  lines.push(`**Reversão:** snapshot/restore de bytes, md5 de cada arquivo conferido${bad.length ? ` — FALHOU em ${bad.join(', ')}` : ' (todos iguais ao original)'}; sem \`git checkout\`. Escrita nova a cada restauração, então o arquivo é mais novo que qualquer binário de mutante e o build recompila.`);
-  lines.push(`**Binário:** ${BINARY[result.binary.proof]}.`);
-  lines.push(`**Árvore:** \`git status --porcelain\` ${r.treeClean ? 'idêntico ao de antes da rodada (vazio em src/)' : 'DIFERENTE do de antes da rodada — investigar antes de qualquer nota'}.`);
-  const sum = result.timings.reduce((acc, t) => acc + t.ms, 0);
-  const jobs = method.jobs ?? 1;
-  const wall = result.wallMs ?? sum;
-  lines.push(`**Tempo:** ${seconds(wall)} de relógio${jobs > 1 ? ` com ${jobs} workers` : ''}; soma das ${result.timings.length} etapas de build+teste: ${seconds(sum)}.`);
-  lines.push('');
-  return lines.join('\n');
-}
-
-export function summarize(result) {
-  const tally = { killed: 0, survived: 0, 'build-error': 0, inconclusive: 0 };
-  for (const m of result.mutants) tally[m.verdict] = (tally[m.verdict] ?? 0) + 1;
-  return tally;
-}