probatio 0.3.0 → 0.5.1

package/dist/mutate/affected.js

@@ -1,173 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import path from "node:path";
-const IMPORT_SPEC = /(?:from\s+|import\s*\(\s*|import\s+)["'](\.{1,2}\/[^"']+)["']/g;
-/** Package-relative source file to the test files that can see a change in it. */
-export function affectedTests(packageDir, options = {}) {
-    const srcRel = options.srcDir ?? "src";
-    const testsRel = options.testsDir ?? "tests";
-    const srcDir = path.join(packageDir, srcRel);
-    const testsDir = path.join(packageDir, testsRel);
-    const alwaysPattern = options.alwaysPattern ?? /\b(?:spawn|execFile|execSync)\b|dist\//;
-    const sources = walk(srcDir, (name) => /\.(ts|tsx|py)$/.test(name) && !name.endsWith(".d.ts"));
-    const tests = existsSync(testsDir)
-        ? readdirSync(testsDir)
-            .filter((name) => /\.test\.(ts|tsx|mts|js|mjs)$/.test(name))
-            .sort()
-        : [];
-    const imports = new Map();
-    const read = (file) => {
-        const found = imports.get(file);
-        if (found)
-            return found;
-        const out = new Set();
-        imports.set(file, out);
-        if (!existsSync(file))
-            return out;
-        const text = readFileSync(file, "utf8");
-        for (const match of text.matchAll(IMPORT_SPEC)) {
-            const resolved = resolveImport(path.dirname(file), match[1]);
-            if (resolved)
-                out.add(resolved);
-        }
-        return out;
-    };
-    const closureOf = (file) => {
-        const seen = new Set();
-        const stack = [file];
-        while (stack.length) {
-            const current = stack.pop();
-            if (!current || seen.has(current))
-                continue;
-            seen.add(current);
-            for (const next of read(current))
-                stack.push(next);
-        }
-        return seen;
-    };
-    const rel = (file) => path.relative(packageDir, file).split(path.sep).join("/");
-    const byModule = new Map();
-    for (const source of sources)
-        byModule.set(rel(source), new Set());
-    const testRel = (name) => `${testsRel}/${name}`.replace(/\\/g, "/");
-    const always = [];
-    for (const test of tests) {
-        const text = readFileSync(path.join(testsDir, test), "utf8");
-        if (alwaysPattern.test(text))
-            always.push(testRel(test));
-    }
-    for (const names of byModule.values())
-        for (const test of always)
-            names.add(test);
-    for (const test of tests) {
-        const seen = closureOf(path.join(testsDir, test));
-        for (const file of seen) {
-            const key = rel(file);
-            const testsForFile = byModule.get(key);
-            if (testsForFile)
-                testsForFile.add(testRel(test));
-        }
-        const blob = [path.join(testsDir, test), ...seen].map((file) => (existsSync(file) ? readFileSync(file, "utf8") : "")).join("\n");
-        for (const source of sources) {
-            if (!source.endsWith(".py"))
-                continue;
-            if (blob.includes(path.basename(source)))
-                byModule.get(rel(source))?.add(testRel(test));
-        }
-    }
-    for (const testFile of walk(testsDir, (name) => /^test_.*\.py$/.test(name) || /_test\.py$/.test(name))) {
-        const text = readFileSync(testFile, "utf8");
-        const relTest = rel(testFile);
-        for (const source of sources) {
-            if (!source.endsWith(".py"))
-                continue;
-            const moduleName = pythonModuleName(rel(source));
-            if (!moduleName)
-                continue;
-            const pattern = new RegExp(`(?<![\\w.])${escapeRegExp(moduleName)}(?![\\w.])`);
-            if (pattern.test(text))
-                byModule.get(rel(source))?.add(relTest);
-        }
-    }
-    return Object.fromEntries([...byModule.entries()].sort().map(([file, names]) => [file, [...names].sort()]));
-}
-/** Test files that import one of `changed` themselves, not through another module. */
-export function directImporters(packageDir, changed, testsDir = "tests") {
-    const testsRoot = path.join(packageDir, testsDir);
-    if (!existsSync(testsRoot))
-        return [];
-    const wanted = new Set(changed.map((file) => path.resolve(packageDir, file)));
-    const out = [];
-    const seen = new Set();
-    const add = (rel) => {
-        if (seen.has(rel))
-            return;
-        seen.add(rel);
-        out.push(rel);
-    };
-    for (const name of readdirSync(testsRoot).filter((item) => /\.test\.(ts|tsx|mts|js|mjs)$/.test(item)).sort()) {
-        const file = path.join(testsRoot, name);
-        const text = readFileSync(file, "utf8");
-        for (const match of text.matchAll(IMPORT_SPEC)) {
-            const resolved = resolveImport(path.dirname(file), match[1]);
-            if (resolved && wanted.has(resolved)) {
-                add(`${testsDir}/${name}`.replace(/\\/g, "/"));
-                break;
-            }
-        }
-    }
-    const patterns = changed
-        .map((file) => pythonModuleName(file))
-        .filter((name) => name !== null)
-        .map((name) => new RegExp(`(?<![\\w.])${escapeRegExp(name)}(?![\\w.])`));
-    if (patterns.length > 0) {
-        for (const file of walk(testsRoot, (name) => /^test_.*\.py$/.test(name) || /_test\.py$/.test(name))) {
-            const text = readFileSync(file, "utf8");
-            if (!patterns.some((pattern) => pattern.test(text)))
-                continue;
-            add(path.relative(packageDir, file).split(path.sep).join("/"));
-        }
-    }
-    return out;
-}
-/** `src/pkg/mod.py` is the import name `pkg.mod`. */
-function pythonModuleName(file) {
-    const norm = file.split(path.sep).join("/");
-    if (!norm.endsWith(".py"))
-        return null;
-    let body = norm.slice(0, -3);
-    if (body.startsWith("src/"))
-        body = body.slice(4);
-    if (body.endsWith("/__init__"))
-        body = body.slice(0, -"/__init__".length);
-    if (!body || body.startsWith("../"))
-        return null;
-    return body.split("/").join(".");
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function resolveImport(fromDir, spec) {
-    const target = path.resolve(fromDir, spec);
-    const candidates = [target, `${target}.ts`, `${target}.tsx`, `${target}.mts`, `${target}.js`, `${target}.mjs`, `${target}.py`];
-    for (const candidate of candidates) {
-        if (existsSync(candidate) && statSync(candidate).isFile())
-            return candidate;
-    }
-    return null;
-}
-function walk(dir, keep) {
-    if (!existsSync(dir))
-        return [];
-    const out = [];
-    const visit = (current) => {
-        for (const entry of readdirSync(current).sort()) {
-            const full = path.join(current, entry);
-            if (statSync(full).isDirectory())
-                visit(full);
-            else if (keep(entry))
-                out.push(full);
-        }
-    };
-    visit(dir);
-    return out;
-}

package/dist/mutate/child-lines.mjs

@@ -1,39 +0,0 @@
-// Nameless line dump for a node child of a test. This is not a node:test process and it
-// does not write a coverage shard. The parent test's afterEach reads the dump.
-// The test-process collector puts this file in NODE_OPTIONS, so the child needs no import.
-// The dump is written on `exit`, which also runs after process.exit(), so it is synchronous.
-import { randomBytes } from "node:crypto"
-import { mkdirSync, writeFileSync } from "node:fs"
-import path from "node:path"
-import { openSyncLineSampler } from "./precise-lines.mjs"
-
-const mapPath = process.env.PROBATIO_COVERAGE_MAP
-if (mapPath && !globalThis.__probatioChildLines) {
-  globalThis.__probatioChildLines = true
-  let sampler = null
-  try {
-    sampler = openSyncLineSampler(
-      (rel) => rel.endsWith("child-lines.mjs") || rel.endsWith("precise-lines.mjs"),
-      process.env.PROBATIO_PACKAGE_ROOT || process.cwd(),
-    )
-  } catch (err) {
-    writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
-  }
-  if (sampler) {
-    process.on("exit", () => {
-      // A node:test process that loaded this through an inherited NODE_OPTIONS has its own
-      // hooks. Its hits are already named. A nameless dump would land on the wrong test.
-      if (globalThis.__probatioTestHooks) return
-      try {
-        const hits = sampler.positiveLines()
-        // A child started by a mapped test writes where that test's process reads.
-        // A child that was not (a script that imports this file itself) uses the shared dir.
-        const dir = process.env.PROBATIO_CHILD_DIR || `${mapPath}.children`
-        mkdirSync(dir, { recursive: true })
-        writeFileSync(path.join(dir, `${process.pid}-${randomBytes(4).toString("hex")}.json`), JSON.stringify({ hits }))
-      } catch (err) {
-        writeFileSync(`${mapPath}.error`, `${err instanceof Error ? err.message : String(err)}\n`)
-      }
-    })
-  }
-}

package/dist/mutate/coverage-map.js

@@ -1,229 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { WHOLE_PROGRAM_TEST } from "./suite-decision.js";
-export function readCoverageMap(file) {
-    if (!existsSync(file))
-        return null;
-    try {
-        const parsed = JSON.parse(readFileSync(file, "utf8"));
-        if (!parsed || typeof parsed.files !== "object" || parsed.files === null)
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-/** Lines the baseline executed, and the tests that hit them. No map means no decision. */
-export function selectionFor(map, files) {
-    if (!map || Object.keys(map.files).length === 0 || files.length === 0)
-        return { state: "none" };
-    const tests = new Set();
-    let sawUncovered = false;
-    let uncovered = files[0];
-    for (const item of files) {
-        const hit = testsOnLine(map, item.file, item.line);
-        if (hit === null) {
-            sawUncovered = true;
-            uncovered = item;
-            continue;
-        }
-        for (const name of hit)
-            tests.add(name);
-    }
-    if (tests.size === 0 && sawUncovered)
-        return { state: "uncovered", file: uncovered.file, line: uncovered.line };
-    if (tests.size === 0)
-        return { state: "none" };
-    const [file, line] = coveredAnchor(map, files);
-    return { state: "covered", file, line, tests: [...tests] };
-}
-function coveredAnchor(map, files) {
-    for (const item of files) {
-        if (testsOnLine(map, item.file, item.line))
-            return [item.file, item.line];
-    }
-    return [files[0].file, files[0].line];
-}
-function testsOnLine(map, file, line) {
-    const lines = linesFor(map, file);
-    if (!lines)
-        return null;
-    const tests = lines[String(line)];
-    if (!tests || tests.length === 0)
-        return null;
-    return tests;
-}
-function linesFor(map, file) {
-    const norm = file.split(path.sep).join("/");
-    if (map.files[norm])
-        return map.files[norm];
-    if (map.files[file])
-        return map.files[file];
-    // A repo-relative patch can be longer than the package-relative map key.
-    // The longest suffix wins, so span/simple.py does not steal span_handlers/simple.py.
-    let best = null;
-    let bestLen = -1;
-    const baseHits = [];
-    const base = norm.split("/").pop() ?? norm;
-    for (const [name, lines] of Object.entries(map.files)) {
-        const key = name.split(path.sep).join("/");
-        if (key === norm || norm.endsWith(`/${key}`) || key.endsWith(`/${norm}`)) {
-            if (key.length > bestLen) {
-                best = lines;
-                bestLen = key.length;
-            }
-        }
-        if (key === base || key.endsWith(`/${base}`))
-            baseHits.push(lines);
-    }
-    if (best)
-        return best;
-    if (baseHits.length === 1)
-        return baseHits[0];
-    return null;
-}
-export function binaryFromCommand(command, pkg) {
-    const match = command.match(/(?:^|\s)-o\s+["']?([^\s"']+)["']?/);
-    if (!match)
-        return null;
-    const rel = match[1];
-    const full = path.isAbsolute(rel) ? rel : path.join(pkg, rel);
-    return existsSync(full) ? full : null;
-}
-/**
- * Build a line map from LLVM profraw left by an instrumented baseline.
- * Writes nothing when llvm-cov cannot start or no profile was produced.
- */
-export function writeLlvmCoverage(pkg, profileDir, binary, dest) {
-    if (!existsSync(profileDir))
-        return { ok: false, detail: "no profile directory" };
-    const raws = readdirSync(profileDir).filter((name) => name.endsWith(".profraw")).map((name) => path.join(profileDir, name));
-    if (raws.length === 0)
-        return { ok: false, detail: "no profraw" };
-    if (!binary)
-        return { ok: false, detail: "no instrumented binary" };
-    const merged = path.join(profileDir, "baseline.profdata");
-    const exported = exportLlvmProfile(binary, raws, merged);
-    if (!exported.ok)
-        return exported;
-    const map = llvmExportToMap(exported.stdout, pkg);
-    if (!map)
-        return { ok: false, detail: "llvm-cov export was not a coverage map" };
-    writeFileSync(dest, `${JSON.stringify(map, null, 2)}\n`);
-    return { ok: true, detail: `${Object.keys(map.files).length} files` };
-}
-function llvmExportToMap(stdout, pkg) {
-    const start = stdout.indexOf("{");
-    if (start < 0)
-        return null;
-    let parsed;
-    try {
-        parsed = JSON.parse(stdout.slice(start));
-    }
-    catch {
-        return null;
-    }
-    const files = {};
-    const root = pkg.endsWith(path.sep) ? pkg : `${pkg}${path.sep}`;
-    for (const group of parsed.data ?? []) {
-        for (const file of group.files ?? []) {
-            if (!file.filename)
-                continue;
-            const lines = {};
-            for (const segment of file.segments ?? []) {
-                const line = segment[0];
-                const count = segment[2] ?? 0;
-                if (!line || count <= 0)
-                    continue;
-                lines[String(line)] = [WHOLE_PROGRAM_TEST];
-            }
-            if (Object.keys(lines).length === 0)
-                continue;
-            let rel = file.filename;
-            if (rel.startsWith(root))
-                rel = rel.slice(root.length);
-            rel = rel.split(path.sep).join("/");
-            files[rel] = { ...(files[rel] ?? {}), ...lines };
-        }
-    }
-    if (Object.keys(files).length === 0)
-        return null;
-    return { files };
-}
-/**
- * clang and rustc write different profraw versions. Each pair is one LLVM install.
- * The first pair that can merge the profile wins.
- */
-export function llvmToolsPresent() {
-    return llvmToolPairs().length > 0;
-}
-export function exportLlvmProfile(binary, raws, merged) {
-    const pairs = llvmToolPairs();
-    if (pairs.length === 0)
-        return { ok: false, detail: "llvm tool missing (llvm-cov)" };
-    let detail = "llvm-profdata failed";
-    for (const { cov, prof } of pairs) {
-        const merge = spawnSync(prof, ["merge", "-sparse", "-o", merged, ...raws], { encoding: "utf8" });
-        if (merge.status !== 0) {
-            detail = (merge.stderr || merge.stdout || "llvm-profdata failed").trim();
-            continue;
-        }
-        const exported = spawnSync(cov, ["export", binary, `-instr-profile=${merged}`], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
-        if (exported.status !== 0) {
-            detail = (exported.stderr || exported.stdout || "llvm-cov failed").trim();
-            continue;
-        }
-        return { ok: true, stdout: exported.stdout };
-    }
-    return { ok: false, detail };
-}
-function llvmToolPairs() {
-    const covs = toolCandidates("llvm-cov");
-    const profs = toolCandidates("llvm-profdata");
-    const pairs = [];
-    const seen = new Set();
-    for (const cov of covs) {
-        const prof = profs.find((item) => path.dirname(item) === path.dirname(cov));
-        if (!prof)
-            continue;
-        const key = `${cov}\0${prof}`;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        pairs.push({ cov, prof });
-    }
-    return pairs;
-}
-function toolCandidates(name) {
-    const out = [];
-    const add = (file) => {
-        if (!file || out.includes(file) || !existsSync(file))
-            return;
-        out.push(file);
-    };
-    const fromXcrun = spawnSync("xcrun", ["--find", name], { encoding: "utf8" });
-    if (fromXcrun.status === 0)
-        add((fromXcrun.stdout ?? "").trim());
-    const which = spawnSync("sh", ["-c", `command -v ${name}`], { encoding: "utf8" });
-    if (which.status === 0)
-        add((which.stdout ?? "").trim());
-    const rustc = spawnSync("rustc", ["--print", "sysroot"], { encoding: "utf8" });
-    if (rustc.status === 0) {
-        const root = path.join(rustc.stdout.trim(), "lib", "rustlib");
-        if (existsSync(root)) {
-            for (const host of readdirSync(root))
-                add(path.join(root, host, "bin", name));
-        }
-    }
-    const usr = "/usr/lib";
-    if (existsSync(usr)) {
-        for (const dir of readdirSync(usr)) {
-            if (dir.startsWith("llvm-"))
-                add(path.join(usr, dir, "bin", name));
-        }
-    }
-    add(path.join("/usr/bin", name));
-    return out;
-}

package/dist/mutate/csharp-coverage.js

@@ -1,161 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
-import path from "node:path";
-/**
- * One Coverlet run per test name. The collector's report does not name the test,
- * so each name gets its own results directory.
- */
-export function writeCsharpCoverage(pkg, testNames, dest, project) {
-    const names = [...new Set(testNames.map((name) => name.trim()).filter((name) => name.length > 0))];
-    if (names.length === 0)
-        return { ok: false, detail: "csharp coverage: no test names" };
-    const work = path.join(path.dirname(dest), "csharp-cover");
-    mkdirSync(work, { recursive: true });
-    const settings = path.join(work, "coverlet.runsettings");
-    // Coverlet skips the test assembly unless asked. A one-project suite keeps the code there.
-    writeFileSync(settings, [
-        '<?xml version="1.0" encoding="utf-8"?>',
-        "<RunSettings>",
-        "  <DataCollectionRunSettings>",
-        "    <DataCollectors>",
-        '      <DataCollector friendlyName="XPlat Code Coverage">',
-        "        <Configuration>",
-        "          <Format>cobertura</Format>",
-        "          <IncludeTestAssembly>true</IncludeTestAssembly>",
-        "        </Configuration>",
-        "      </DataCollector>",
-        "    </DataCollectors>",
-        "  </DataCollectionRunSettings>",
-        "</RunSettings>",
-        "",
-    ].join("\n"));
-    const files = {};
-    const env = dotnetEnv();
-    for (const name of names) {
-        const results = path.join(work, safe(name));
-        mkdirSync(results, { recursive: true });
-        const args = ["test", "--nologo", "--verbosity", "quiet", "--settings", settings];
-        if (project)
-            args.push(project);
-        args.push("--filter", `FullyQualifiedName~${name}`, "--collect", "XPlat Code Coverage", "--results-directory", results);
-        const ran = spawnSync("dotnet", args, { cwd: pkg, encoding: "utf8", env, timeout: 180_000, maxBuffer: 16 * 1024 * 1024 });
-        if (ran.status !== 0 || ran.error)
-            continue;
-        const report = findCobertura(results);
-        if (!report)
-            continue;
-        let text = "";
-        try {
-            text = readFileSync(report, "utf8");
-        }
-        catch {
-            continue;
-        }
-        addCobertura(files, text, pkg, name);
-    }
-    if (Object.keys(files).length === 0)
-        return { ok: false, detail: "csharp coverage: no covered lines" };
-    writeFileSync(dest, `${JSON.stringify({ files }, null, 2)}\n`);
-    return { ok: true, detail: `${Object.keys(files).length} files` };
-}
-function addCobertura(files, text, pkg, test) {
-    const sources = [...text.matchAll(/<source>([^<]+)<\/source>/g)].map((match) => match[1].trim());
-    for (const part of text.split(/<class\b/).slice(1)) {
-        const headEnd = part.indexOf(">");
-        if (headEnd < 0)
-            continue;
-        const filename = /filename="([^"]+)"/.exec(part.slice(0, headEnd))?.[1];
-        if (!filename)
-            continue;
-        const bodyEnd = part.indexOf("</class>");
-        const body = bodyEnd >= 0 ? part.slice(0, bodyEnd) : part;
-        const rel = coberturaRel(filename, sources, pkg);
-        if (!rel)
-            continue;
-        for (const tag of body.match(/<line\b[^>]*\/?>/g) ?? []) {
-            const number = /number="(\d+)"/.exec(tag);
-            const hits = /hits="(\d+)"/.exec(tag);
-            if (!number || !hits || Number(hits[1]) <= 0)
-                continue;
-            addHit(files, rel, Number(number[1]), test);
-        }
-    }
-}
-function coberturaRel(filename, sources, pkg) {
-    const norm = filename.split("\\").join("/");
-    const candidates = norm.startsWith("/") || /^[A-Za-z]:\//.test(norm) ? [norm] : [norm];
-    for (const source of sources) {
-        const root = source.endsWith("/") || source.endsWith("\\") ? source : `${source}/`;
-        candidates.push(path.normalize(`${root}${norm}`));
-    }
-    for (const candidate of candidates) {
-        const rel = underPkg(candidate, pkg);
-        if (rel)
-            return rel;
-    }
-    return null;
-}
-function underPkg(filename, pkg) {
-    if (!existsSync(filename))
-        return null;
-    let file = filename;
-    let root = pkg;
-    try {
-        file = realpathSync(filename);
-        root = realpathSync(pkg);
-    }
-    catch {
-        return null;
-    }
-    const rel = path.relative(root, file);
-    if (!rel || rel.startsWith(".."))
-        return null;
-    return rel.split(path.sep).join("/");
-}
-function findCobertura(dir) {
-    const found = [];
-    const visit = (current) => {
-        let entries;
-        try {
-            entries = readdirSync(current);
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            const full = path.join(current, entry);
-            let info;
-            try {
-                info = statSync(full);
-            }
-            catch {
-                continue;
-            }
-            if (info.isDirectory()) {
-                visit(full);
-                continue;
-            }
-            if (entry === "coverage.cobertura.xml")
-                found.push(full);
-        }
-    };
-    visit(dir);
-    return found[0] ?? null;
-}
-function addHit(files, file, line, test) {
-    const lines = files[file] ?? {};
-    const key = String(line);
-    const names = lines[key] ?? [];
-    if (!names.includes(test))
-        names.push(test);
-    lines[key] = names;
-    files[file] = lines;
-}
-function dotnetEnv() {
-    if (process.env.DOTNET_ROLL_FORWARD)
-        return process.env;
-    return { ...process.env, DOTNET_ROLL_FORWARD: "Major" };
-}
-function safe(value) {
-    return value.replace(/[^A-Za-z0-9._-]+/g, "_");
-}

package/dist/mutate/fail-reporter.mjs

@@ -1,65 +0,0 @@
-// node --test custom reporter. One JSON object on stdout: failures with the file
-// the runner itself recorded. TAP headings are not used.
-import { staticLoadFailure } from "./load-failure.mjs"
-
-export default async function* reporter(source) {
-  // A file that fails to load prints its error on stderr before the file-level failure.
-  const stderr = new Map()
-  const failed = []
-  const names = []
-  let tests = 0
-  let pass = 0
-  let fail = 0
-  for await (const event of source) {
-    if (event.type === "test:stderr") {
-      const key = String(event.data?.file ?? "")
-      stderr.set(key, `${stderr.get(key) ?? ""}${String(event.data?.message ?? "")}`)
-      continue
-    }
-    if (event.type === "test:pass" || event.type === "test:fail") {
-      const data = event.data ?? {}
-      if (data.details && data.details.type === "suite") continue
-      const name = String(data.name ?? "")
-      const file = String(data.file ?? "")
-      names.push(name)
-      if (event.type === "test:fail") {
-        const failure = { name, file, line: Number(data.line ?? 0) }
-        // An open handle is reported as a timeout whose name is the file path.
-        // failureType lives on the error; the text is on error.cause, not message.
-        if (fileTimedOut(name, file, data.details?.error)) failure.fileTimeout = true
-        // The file itself failed and no test in it ran: it did not load.
-        else if (isFileName(name, file)) {
-          failure.fileLoad = true
-          // It did not link (removed export, missing module, no parse): no test code ran.
-          if (staticLoadFailure(stderr.get(file) ?? "")) failure.staticLoad = true
-        }
-        failed.push(failure)
-      }
-    } else if (event.type === "test:diagnostic") {
-      const message = String(event.data?.message ?? "")
-      const match = message.match(/^(tests|pass|fail) (\d+)$/)
-      if (!match) continue
-      const count = Number(match[2])
-      if (match[1] === "tests") tests = count
-      else if (match[1] === "pass") pass = count
-      else fail = count
-    }
-  }
-  yield JSON.stringify({ tests, pass, fail, failed, names })
-}
-
-function isFileName(name, file) {
-  const base = String(file).split(/[/\\]/).pop()
-  if (!base) return false
-  return name === file || name === base || name.endsWith(`/${base}`) || name.endsWith(`\\${base}`)
-}
-
-function fileTimedOut(name, file, error) {
-  if (!error || typeof error !== "object") return false
-  const cause = typeof error.cause === "string" ? error.cause : ""
-  const text = `${error.failureType ?? ""} ${error.message ?? ""} ${cause}`
-  if (!/testTimeoutFailure|timed out/i.test(text)) return false
-  const base = String(file).split(/[/\\]/).pop()
-  if (!base) return false
-  return name === file || name === base || name.endsWith(`/${base}`) || name.endsWith(`\\${base}`)
-}

package/dist/mutate/find.js

@@ -1,13 +0,0 @@
-import { findMutants } from "./operators.js";
-import { findTextMutants, textKind } from "./text-operators.js";
-/** TypeScript stays on the TypeScript parser. Every other recognized source uses its own finder. */
-export function findInSource(file, text, operators = "core") {
-    if (textKind(file))
-        return findTextMutants(file, text, operators);
-    return findMutants(file, text, operators);
-}
-export function isGeneratedSource(name) {
-    if (textKind(name))
-        return true;
-    return (name.endsWith(".ts") || name.endsWith(".tsx")) && !name.endsWith(".d.ts");
-}