probatio 0.0.0-stage → 0.0.2

package/dist/mutate/text-operators.js

@@ -0,0 +1,547 @@
+import path from "node:path";
+const C_OPS = [
+    { original: "&&", op: "and-to-or", replacement: "||" },
+    { original: "||", op: "or-to-and", replacement: "&&" },
+    { original: "<=", op: "le-to-lt", replacement: "<" },
+    { original: ">=", op: "ge-to-gt", replacement: ">" },
+    { original: "==", op: "eq-to-neq", replacement: "!=" },
+    { original: "!=", op: "neq-to-eq", replacement: "==" },
+    { original: "<", op: "lt-to-le", replacement: "<=" },
+    { original: ">", op: "gt-to-ge", replacement: ">=" },
+];
+const PY_WORDS = [
+    { original: "and", op: "and-to-or", replacement: "or" },
+    { original: "or", op: "or-to-and", replacement: "and" },
+];
+const EQ_OPS = [
+    { original: "===", op: "eq-to-neq", replacement: "!==" },
+    { original: "!==", op: "neq-to-eq", replacement: "===" },
+];
+const X86_OPS = [
+    { original: "je", op: "eq-to-neq", replacement: "jne" },
+    { original: "jne", op: "neq-to-eq", replacement: "je" },
+    { original: "jz", op: "eq-to-neq", replacement: "jnz" },
+    { original: "jnz", op: "neq-to-eq", replacement: "jz" },
+    { original: "jg", op: "gt-to-ge", replacement: "jge" },
+    { original: "jge", op: "ge-to-gt", replacement: "jg" },
+    { original: "jl", op: "lt-to-le", replacement: "jle" },
+    { original: "jle", op: "le-to-lt", replacement: "jl" },
+    { original: "ja", op: "gt-to-ge", replacement: "jae" },
+    { original: "jae", op: "ge-to-gt", replacement: "ja" },
+    { original: "jb", op: "lt-to-le", replacement: "jbe" },
+    { original: "jbe", op: "le-to-lt", replacement: "jb" },
+    { original: "and", op: "and-to-or", replacement: "or" },
+    { original: "or", op: "or-to-and", replacement: "and" },
+];
+const ARM_OPS = [
+    { original: "b.eq", op: "eq-to-neq", replacement: "b.ne" },
+    { original: "b.ne", op: "neq-to-eq", replacement: "b.eq" },
+    { original: "b.gt", op: "gt-to-ge", replacement: "b.ge" },
+    { original: "b.ge", op: "ge-to-gt", replacement: "b.gt" },
+    { original: "b.lt", op: "lt-to-le", replacement: "b.le" },
+    { original: "b.le", op: "le-to-lt", replacement: "b.lt" },
+    { original: "b.hi", op: "gt-to-ge", replacement: "b.hs" },
+    { original: "b.hs", op: "ge-to-gt", replacement: "b.hi" },
+    { original: "b.lo", op: "lt-to-le", replacement: "b.ls" },
+    { original: "b.ls", op: "le-to-lt", replacement: "b.lo" },
+    { original: "cbz", op: "eq-to-neq", replacement: "cbnz" },
+    { original: "cbnz", op: "neq-to-eq", replacement: "cbz" },
+];
+const RISCV_OPS = [
+    { original: "beq", op: "eq-to-neq", replacement: "bne" },
+    { original: "bne", op: "neq-to-eq", replacement: "beq" },
+    { original: "blt", op: "lt-to-le", replacement: "bge" },
+    { original: "bge", op: "le-to-lt", replacement: "blt" },
+    { original: "bltu", op: "lt-to-le", replacement: "bgeu" },
+    { original: "bgeu", op: "le-to-lt", replacement: "bltu" },
+];
+/** Which text finder owns this path. TypeScript stays null so the TS parser is not used. */
+export function textKind(file) {
+    switch (path.extname(file).toLowerCase()) {
+        case ".py":
+            return "python";
+        case ".cob":
+        case ".cbl":
+        case ".cobol":
+            return "cobol";
+        case ".rs":
+            return "rust";
+        case ".go":
+            return "go";
+        case ".java":
+        case ".c":
+        case ".h":
+        case ".cpp":
+        case ".cc":
+        case ".cxx":
+        case ".hpp":
+        case ".hh":
+        case ".hxx":
+            return "c";
+        case ".js":
+        case ".mjs":
+        case ".cjs":
+            return "js";
+        case ".cs":
+            return "csharp";
+        case ".swift":
+            return "swift";
+        case ".asm":
+        case ".nasm":
+        case ".yasm":
+            return "asm-x86_64";
+        case ".s":
+        case ".S":
+            return "asm-aarch64";
+        default:
+            return null;
+    }
+}
+/**
+ * Operator mutants for one non-TypeScript source. Strings and comments are skipped
+ * before a point is proposed, so a `/*`, `*>`, or `#` inside a string cannot hide later code.
+ */
+export function findTextMutants(file, text) {
+    const kind = resolveKind(file, text);
+    if (!kind)
+        return { points: [], violations: [] };
+    const code = codeMask(text, kind);
+    const points = [];
+    let line = 1;
+    let index = 0;
+    while (index < text.length) {
+        if (text[index] === "\n") {
+            line += 1;
+            index += 1;
+            continue;
+        }
+        const match = code[index] ? matchAt(text, index, code, kind) : null;
+        if (!match) {
+            index += 1;
+            continue;
+        }
+        points.push({
+            file,
+            start: index,
+            end: index + match.original.length,
+            line,
+            op: match.op,
+            original: match.original,
+            replacement: match.replacement,
+        });
+        index += match.original.length;
+    }
+    return { points, violations: [] };
+}
+function matchAt(text, index, code, kind) {
+    const word = matchWord(text, index, code, kind);
+    if (word)
+        return word;
+    for (const op of symbolOps(kind)) {
+        if (!text.startsWith(op.original, index))
+            continue;
+        if (!spanIsCode(code, index, op.original.length))
+            continue;
+        if (blocked(text, index, op.original))
+            continue;
+        return op;
+    }
+    return null;
+}
+function resolveKind(file, text) {
+    const kind = textKind(file);
+    if (!kind)
+        return null;
+    if (kind.startsWith("asm-"))
+        return sniffAsm(file, text);
+    return kind;
+}
+function sniffAsm(file, text) {
+    const ext = path.extname(file);
+    const lower = ext.toLowerCase();
+    if (lower === ".asm" || lower === ".nasm" || lower === ".yasm")
+        return "asm-x86_64";
+    const riscv = /\b(beq|bne|blt|bge|bltu|bgeu|ecall)\b/.test(text);
+    const arm = /\bb\.(eq|ne|lt|le|gt|ge|hi|hs|lo|ls)\b/.test(text) || /\b(adrp|svc)\b/.test(text);
+    if (riscv && !arm)
+        return "asm-riscv";
+    if (arm && !riscv)
+        return "asm-aarch64";
+    // `.S` lowercases to `.s`. A capital S stays RISC-V when the body has no marker.
+    return lower === ".s" && ext !== ".S" ? "asm-aarch64" : "asm-riscv";
+}
+function symbolOps(kind) {
+    if (kind.startsWith("asm-"))
+        return [];
+    if (kind === "cobol")
+        return C_OPS.filter((op) => op.original === "<" || op.original === ">" || op.original === "<=" || op.original === ">=");
+    if (kind === "python")
+        return C_OPS.filter((op) => op.original !== "&&" && op.original !== "||");
+    if (kind === "js" || kind === "swift")
+        return [...EQ_OPS, ...C_OPS];
+    return C_OPS;
+}
+function matchWord(text, index, code, kind) {
+    if (kind === "python")
+        return matchExactWord(text, index, code, PY_WORDS, "");
+    if (kind === "cobol")
+        return matchCobolWord(text, index, code);
+    if (kind === "asm-x86_64")
+        return matchMnemonic(text, index, code, X86_OPS, true);
+    if (kind === "asm-aarch64")
+        return matchMnemonic(text, index, code, ARM_OPS, false);
+    if (kind === "asm-riscv")
+        return matchMnemonic(text, index, code, RISCV_OPS, false);
+    return matchExactWord(text, index, code, [
+        { original: "true", op: "true-to-false", replacement: "false" },
+        { original: "false", op: "false-to-true", replacement: "true" },
+    ], "");
+}
+function matchMnemonic(text, index, code, words, insensitive) {
+    const ordered = [...words].sort((left, right) => right.original.length - left.original.length);
+    for (const word of ordered) {
+        const slice = text.slice(index, index + word.original.length);
+        const same = insensitive ? slice.toLowerCase() === word.original : slice === word.original;
+        if (!same)
+            continue;
+        if (!wordEdge(text, index, index + word.original.length, "."))
+            continue;
+        if (text[index + word.original.length] === ":")
+            continue;
+        if (!spanIsCode(code, index, word.original.length))
+            continue;
+        return { original: slice, op: word.op, replacement: mirrorCase(slice, word.replacement) };
+    }
+    return null;
+}
+function matchExactWord(text, index, code, words, extra) {
+    for (const word of words) {
+        if (!text.startsWith(word.original, index))
+            continue;
+        if (!wordEdge(text, index, index + word.original.length, extra))
+            continue;
+        if (!spanIsCode(code, index, word.original.length))
+            continue;
+        return word;
+    }
+    return null;
+}
+function matchCobolWord(text, index, code) {
+    const words = ["AND", "OR", "TRUE", "FALSE"];
+    for (const word of words) {
+        const slice = text.slice(index, index + word.length);
+        if (slice.toUpperCase() !== word)
+            continue;
+        if (!wordEdge(text, index, index + word.length, "-"))
+            continue;
+        if (!spanIsCode(code, index, word.length))
+            continue;
+        if (word === "AND")
+            return { original: slice, op: "and-to-or", replacement: mirrorCase(slice, "OR") };
+        if (word === "OR")
+            return { original: slice, op: "or-to-and", replacement: mirrorCase(slice, "AND") };
+        if (word === "TRUE")
+            return { original: slice, op: "true-to-false", replacement: mirrorCase(slice, "FALSE") };
+        return { original: slice, op: "false-to-true", replacement: mirrorCase(slice, "TRUE") };
+    }
+    return null;
+}
+function mirrorCase(source, replacement) {
+    if (source === source.toUpperCase())
+        return replacement.toUpperCase();
+    if (source === source.toLowerCase())
+        return replacement.toLowerCase();
+    return replacement[0].toUpperCase() + replacement.slice(1).toLowerCase();
+}
+function wordEdge(text, start, end, extra) {
+    const ident = (ch) => ch !== undefined && (/[A-Za-z0-9_]/.test(ch) || extra.includes(ch));
+    return !ident(text[start - 1]) && !ident(text[end]);
+}
+function spanIsCode(code, start, length) {
+    for (let offset = 0; offset < length; offset += 1)
+        if (!code[start + offset])
+            return false;
+    return true;
+}
+function blocked(text, index, original) {
+    const prev = text[index - 1] ?? "";
+    const next = text[index + original.length] ?? "";
+    // `<-` is a Go channel operator. `=>` is a Rust fat arrow. Neither is a comparison.
+    if (original === "<" && (next === "<" || next === "=" || next === "-" || prev === "<"))
+        return true;
+    if (original === ">" && (next === ">" || next === "=" || prev === ">" || prev === "-" || prev === "="))
+        return true;
+    // Both sides must be whitespace. One side still matches `#include <stdio.h>` and `vector<int>`.
+    if ((original === "<" || original === ">") && !(/\s/.test(prev) && /\s/.test(next)))
+        return true;
+    // `<<=`, `>>=`, and `<=>` contain `<=` or `>=` but are not relational operators.
+    if (original === "<=" && (prev === "<" || next === ">" || next === "="))
+        return true;
+    if (original === ">=" && (prev === ">" || next === "="))
+        return true;
+    if ((original === "==" || original === "!=" || original === "===" || original === "!==") && next === "=")
+        return true;
+    if (original === "&&" && (next === "&" || prev === "&"))
+        return true;
+    if (original === "||" && (next === "|" || prev === "|"))
+        return true;
+    return false;
+}
+function codeMask(text, kind) {
+    const code = new Uint8Array(text.length);
+    let index = 0;
+    while (index < text.length) {
+        const hidden = skipHidden(text, index, kind);
+        if (hidden > index) {
+            index = hidden;
+            continue;
+        }
+        code[index] = 1;
+        index += 1;
+    }
+    return code;
+}
+function skipHidden(text, index, kind) {
+    if (kind === "python")
+        return skipPython(text, index);
+    if (kind === "cobol")
+        return skipCobol(text, index);
+    if (kind === "js")
+        return skipJs(text, index);
+    if (kind === "swift")
+        return skipSwift(text, index);
+    if (kind === "csharp")
+        return skipCSharp(text, index);
+    if (kind === "asm-x86_64")
+        return skipAsm(text, index, { hash: false, semi: true, slash: true });
+    if (kind === "asm-aarch64")
+        return skipAsm(text, index, { hash: false, semi: true, slash: true });
+    if (kind === "asm-riscv")
+        return skipAsm(text, index, { hash: true, semi: false, slash: true });
+    if (kind === "go")
+        return skipC(text, index, { nested: false, rust: false, raw: true });
+    if (kind === "rust")
+        return skipC(text, index, { nested: true, rust: true, raw: false });
+    return skipC(text, index, { nested: false, rust: false, raw: false });
+}
+function skipJs(text, index) {
+    const hidden = skipC(text, index, { nested: false, rust: false, raw: false });
+    if (hidden > index)
+        return hidden;
+    if (text[index] === "`")
+        return skipTemplate(text, index);
+    return index;
+}
+function skipSwift(text, index) {
+    if (text.startsWith('"""', index))
+        return skipQuotes(text, index, '"""', false);
+    return skipC(text, index, { nested: false, rust: false, raw: false });
+}
+function skipCSharp(text, index) {
+    if (text.startsWith('@"', index) || text.startsWith('$@"', index)) {
+        const start = text[index] === "@" ? index + 1 : index + 2;
+        let cursor = start + 1;
+        while (cursor < text.length) {
+            if (text.startsWith('""', cursor)) {
+                cursor += 2;
+                continue;
+            }
+            if (text[cursor] === '"')
+                return cursor + 1;
+            cursor += 1;
+        }
+        return text.length;
+    }
+    return skipC(text, index, { nested: false, rust: false, raw: false });
+}
+function skipTemplate(text, index) {
+    let cursor = index + 1;
+    while (cursor < text.length) {
+        if (text[cursor] === "\\") {
+            cursor += 2;
+            continue;
+        }
+        if (text[cursor] === "`")
+            return cursor + 1;
+        cursor += 1;
+    }
+    return text.length;
+}
+function skipAsm(text, index, mode) {
+    if (mode.slash && text.startsWith("//", index))
+        return eol(text, index);
+    if (mode.semi && text[index] === ";")
+        return eol(text, index);
+    if (mode.hash && text[index] === "#")
+        return eol(text, index);
+    if (text.startsWith("/*", index))
+        return skipBlock(text, index, false);
+    if (text[index] === '"')
+        return skipEscaped(text, index, '"');
+    if (text[index] === "'")
+        return skipEscaped(text, index, "'");
+    return index;
+}
+function skipPython(text, index) {
+    if (text[index] === "#")
+        return eol(text, index);
+    const quoted = pythonStringAt(text, index);
+    if (!quoted)
+        return index;
+    return skipQuotes(text, quoted.quoteAt, quoted.quote, quoted.raw);
+}
+function pythonStringAt(text, index) {
+    if (text[index] === "'" || text[index] === '"') {
+        const quote = text.startsWith(text[index].repeat(3), index) ? text[index].repeat(3) : text[index];
+        return { quoteAt: index, quote, raw: false };
+    }
+    if (index > 0 && /[A-Za-z0-9_]/.test(text[index - 1]))
+        return null;
+    if (!/[rRuUbBfF]/.test(text[index]))
+        return null;
+    let cursor = index;
+    let letters = "";
+    while (cursor < text.length && letters.length < 2 && /[rRuUbBfF]/.test(text[cursor])) {
+        letters += text[cursor];
+        cursor += 1;
+    }
+    if (text[cursor] !== "'" && text[cursor] !== '"')
+        return null;
+    if (!/^(?:[rRfFbBuU]|[rR][fFbB]|[fFbB][rR])$/.test(letters))
+        return null;
+    const quote = text.startsWith(text[cursor].repeat(3), cursor) ? text[cursor].repeat(3) : text[cursor];
+    return { quoteAt: cursor, quote, raw: /[rR]/.test(letters) };
+}
+function skipCobol(text, index) {
+    // Column 7 is the fixed-format indicator. `*` and `/` comment out the whole line.
+    if ((index === 0 || text[index - 1] === "\n") && (text[index + 6] === "*" || text[index + 6] === "/"))
+        return eol(text, index);
+    if (text.startsWith("*>", index))
+        return eol(text, index);
+    if (text[index] !== '"' && text[index] !== "'")
+        return index;
+    const quote = text[index];
+    let cursor = index + 1;
+    while (cursor < text.length) {
+        if (text[cursor] === "\n")
+            return cursor;
+        if (text[cursor] === quote) {
+            if (text[cursor + 1] === quote) {
+                cursor += 2;
+                continue;
+            }
+            return cursor + 1;
+        }
+        cursor += 1;
+    }
+    return text.length;
+}
+function skipC(text, index, mode) {
+    if (mode.rust) {
+        const raw = rustRawEnd(text, index);
+        if (raw !== null)
+            return raw;
+    }
+    if (text.startsWith("//", index))
+        return eol(text, index);
+    if (text.startsWith("/*", index))
+        return skipBlock(text, index, mode.nested);
+    if (text[index] === '"')
+        return skipEscaped(text, index, '"');
+    if (mode.raw && text[index] === "`") {
+        const end = text.indexOf("`", index + 1);
+        return end === -1 ? text.length : end + 1;
+    }
+    if (text[index] !== "'")
+        return index;
+    if (mode.rust)
+        return rustCharEnd(text, index) ?? index;
+    return skipEscaped(text, index, "'");
+}
+function skipBlock(text, index, nested) {
+    if (!nested) {
+        const end = text.indexOf("*/", index + 2);
+        return end === -1 ? text.length : end + 2;
+    }
+    let depth = 1;
+    let cursor = index + 2;
+    while (cursor < text.length && depth > 0) {
+        if (text.startsWith("/*", cursor)) {
+            depth += 1;
+            cursor += 2;
+            continue;
+        }
+        if (text.startsWith("*/", cursor)) {
+            depth -= 1;
+            cursor += 2;
+            continue;
+        }
+        cursor += 1;
+    }
+    return cursor;
+}
+function rustRawEnd(text, index) {
+    if (text[index] !== "r" && !(text[index] === "b" && text[index + 1] === "r"))
+        return null;
+    if (index > 0 && /[A-Za-z0-9_]/.test(text[index - 1]))
+        return null;
+    let cursor = text[index] === "b" ? index + 2 : index + 1;
+    let hashes = 0;
+    while (text[cursor] === "#") {
+        hashes += 1;
+        cursor += 1;
+    }
+    if (text[cursor] !== '"')
+        return null;
+    cursor += 1;
+    const closer = `"${"#".repeat(hashes)}`;
+    const end = text.indexOf(closer, cursor);
+    return end === -1 ? text.length : end + closer.length;
+}
+function rustCharEnd(text, index) {
+    if (text[index + 1] === "\\" && text[index + 2] === "'" && text[index + 3] === "'")
+        return index + 4;
+    if (text[index + 1] === "\\") {
+        let cursor = index + 2;
+        while (cursor < text.length && cursor < index + 12 && text[cursor] !== "'")
+            cursor += 1;
+        return text[cursor] === "'" ? cursor + 1 : null;
+    }
+    if (text[index + 2] === "'")
+        return index + 3;
+    return null;
+}
+function skipEscaped(text, index, quote) {
+    let cursor = index + 1;
+    while (cursor < text.length) {
+        if (text[cursor] === "\\") {
+            cursor += 2;
+            continue;
+        }
+        if (text[cursor] === "\n")
+            return cursor;
+        if (text[cursor] === quote)
+            return cursor + 1;
+        cursor += 1;
+    }
+    return text.length;
+}
+function skipQuotes(text, quoteAt, quote, raw) {
+    let cursor = quoteAt + quote.length;
+    while (cursor < text.length) {
+        if (!raw && text[cursor] === "\\") {
+            cursor += 2;
+            continue;
+        }
+        if (text.startsWith(quote, cursor))
+            return cursor + quote.length;
+        cursor += 1;
+    }
+    return text.length;
+}
+function eol(text, index) {
+    let cursor = index;
+    while (cursor < text.length && text[cursor] !== "\n")
+        cursor += 1;
+    return cursor;
+}

package/dist/mutate/titles.js

@@ -0,0 +1,23 @@
+const TITLE = /^(?:test|it)\((["'`])(.*?)\1/;
+export function titlesInText(text) {
+    const titles = [];
+    for (const line of text.split("\n")) {
+        const match = line.match(TITLE);
+        if (match)
+            titles.push(match[2]);
+    }
+    return titles;
+}
+export function duplicateTitles(files) {
+    const seen = new Map();
+    for (const file of files) {
+        for (const title of titlesInText(file.text)) {
+            const list = seen.get(title) ?? [];
+            list.push(file.file);
+            seen.set(title, list);
+        }
+    }
+    return [...seen.entries()]
+        .filter(([, files]) => files.length > 1)
+        .map(([title, files]) => ({ title, files }));
+}

package/dist/swarm/check-kill.js

@@ -0,0 +1,107 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { SCHEMA_VERSION } from "../contract.js";
+import { directImporters } from "../mutate/affected.js";
+import { filesInDiff } from "../mutate/patch.js";
+import { killLabel } from "../mutate/kill-label.js";
+import { runMutants } from "../mutate/run.js";
+import { campaignSummary } from "../mutate/suite-decision.js";
+/** The gap is done only when this mutant is killed and the baseline suite is green. */
+export async function checkKill(id, options) {
+    const importers = importersOf(id, options);
+    if (importers.length === 0) {
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            ok: false,
+            command: "check-kill",
+            summary: `${id} is not done. no direct importer in ${options.testsDir}`,
+            next: "The task is not done.",
+            nextCall: null,
+            done: false,
+            outcome: null,
+            suiteGreen: false,
+        };
+    }
+    const report = await runMutants({ ...options, onlyTests: importers, onlyPatch: id, affected: false });
+    const baselineFile = path.join(options.outDir, "baseline.json");
+    let suiteGreen = false;
+    if (existsSync(baselineFile)) {
+        const baseline = JSON.parse(readFileSync(baselineFile, "utf8"));
+        suiteGreen = baseline.ok === true;
+    }
+    // A red baseline stops inside the run. Do not read a result that names the broken test.
+    if (!report.ok) {
+        return {
+            schemaVersion: SCHEMA_VERSION,
+            ok: false,
+            command: "check-kill",
+            summary: `${id} is not done. ${report.summary}`,
+            next: "The task is not done.",
+            nextCall: null,
+            done: false,
+            outcome: null,
+            suiteGreen,
+            killedBy: [],
+        };
+    }
+    const resultFile = path.join(options.outDir, "results", `${id}.json`);
+    let outcome = null;
+    let killedBy = [];
+    if (existsSync(resultFile)) {
+        const result = JSON.parse(readFileSync(resultFile, "utf8"));
+        outcome = result.outcome ?? null;
+        killedBy = Array.isArray(result.killedBy) ? result.killedBy : [];
+    }
+    const done = suiteGreen && outcome === "killed";
+    const label = done ? killLabel(killedBy) : null;
+    const head = checkHead(report);
+    return {
+        schemaVersion: SCHEMA_VERSION,
+        ok: done,
+        command: "check-kill",
+        summary: done ? `${head} ${id} is dead and the suite is green.` : `${head} ${id} is not done.`,
+        next: label?.next ?? (done ? "The gap-fixing task is done." : "The task is not done."),
+        nextCall: null,
+        done,
+        outcome,
+        cause: label?.cause ?? null,
+        killedBy,
+        suiteGreen,
+    };
+}
+/** Same direct-importer set verify-change runs for a diff that touches this mutant's file. */
+function importersOf(id, options) {
+    const patch = options.patchDirs.map((dir) => path.join(dir, `${id}.patch`)).find((file) => existsSync(file));
+    if (!patch)
+        return [];
+    const rels = filesInDiff(readFileSync(patch, "utf8")).map((item) => packageRelative(options.repoDir, options.packageDir, item.file));
+    return directImporters(options.packageDir, rels, options.testsDir);
+}
+function checkHead(report) {
+    const finished = report.killed + report.survived + report.flaky + report.timeouts + report.errors + report.noCoverage;
+    return campaignSummary({
+        noCoverage: report.noCoverage,
+        survived: report.survived,
+        killed: report.killed,
+        flaky: report.flaky,
+        timeouts: report.timeouts,
+        errors: report.errors,
+        finished,
+    });
+}
+function packageRelative(repoDir, packageDir, file) {
+    const norm = file.split(path.sep).join("/");
+    let repo = repoDir;
+    let pkg = packageDir;
+    try {
+        repo = realpathSync(repoDir);
+        pkg = realpathSync(packageDir);
+    }
+    catch {
+        // A missing path still has a relative prefix.
+    }
+    const prefix = path.relative(repo, pkg).split(path.sep).join("/");
+    if (prefix && prefix !== "." && !prefix.startsWith("..") && norm.startsWith(`${prefix}/`))
+        return norm.slice(prefix.length + 1);
+    return norm;
+}