as-test 1.1.1 → 1.1.3

package/bin/reporters/default.js

@@ -2,8 +2,8 @@ import chalk from "chalk";
 import { diff } from "typer-diff";
 import { readFileSync } from "fs";
 import * as path from "path";
-import { formatTime } from "../util.js";
-import { describeCoveragePoint, readCoverageSourceLine, resolveCoverageHighlightSpan, } from "../coverage-points.js";
+import { formatSpecDisplayPath, formatTime } from "../util.js";
+import { describeCoveragePoint } from "../coverage-points.js";
 export const createReporter = (context) => {
     return new DefaultReporter(context);
 };
@@ -55,7 +55,9 @@ class DefaultReporter {
     renderLiveState() {
         if (!this.canRewriteLine() || !this.currentFile)
             return;
-        const lines = [`${this.badgeRunning()} ${this.currentFile}`];
+        const lines = [
+            `${this.badgeRunning()} ${formatSpecDisplayPath(this.currentFile)}`,
+        ];
         for (const suite of this.openSuites) {
             lines.push(`${"  ".repeat(suite.depth + 1)}${this.badgeRunning()} ${suite.description}`);
         }
@@ -67,7 +69,7 @@ class DefaultReporter {
         const lines = [
             fileEnd
                 ? this.renderFileResult(fileEnd)
-                : `${this.badgeRunning()} ${this.currentFile}`,
+                : `${this.badgeRunning()} ${formatSpecDisplayPath(this.currentFile)}`,
         ];
         for (const suite of this.verboseSuites) {
             const badge = suite.verdict == "running"
@@ -112,13 +114,14 @@ class DefaultReporter {
     renderFileResult(event) {
         const verdict = event.verdict ?? "none";
         const time = event.time ? ` ${chalk.dim(event.time)}` : "";
+        const file = formatSpecDisplayPath(event.file);
         if (verdict == "fail")
-            return `${chalk.bgRed.white(" FAIL ")} ${event.file}${time}`;
+            return `${chalk.bgRed.white(" FAIL ")} ${file}${time}`;
         if (this.fileHasWarning)
-            return `${chalk.bgYellow.black(" WARN ")} ${event.file}${time}`;
+            return `${chalk.bgYellow.black(" WARN ")} ${file}${time}`;
         if (verdict == "ok")
-            return `${chalk.bgGreenBright.black(" PASS ")} ${event.file}${time}`;
-        return `${chalk.bgBlackBright.white(" SKIP ")} ${event.file}${time}`;
+            return `${chalk.bgGreenBright.black(" PASS ")} ${file}${time}`;
+        return `${chalk.bgBlackBright.white(" SKIP ")} ${file}${time}`;
     }
     onRunStart(event) {
         this.verboseMode = Boolean(event.verbose);
@@ -139,16 +142,16 @@ class DefaultReporter {
         }
         if (!this.verboseMode) {
             if (!this.canRewriteLine()) {
-                this.context.stdout.write(`${this.badgeRunning()} ${event.file}\n`);
+                this.context.stdout.write(`${this.badgeRunning()} ${formatSpecDisplayPath(event.file)}\n`);
                 return;
             }
             this.clearRenderedBlock();
-            this.context.stdout.write(`${this.badgeRunning()} ${event.file}`);
+            this.context.stdout.write(`${this.badgeRunning()} ${formatSpecDisplayPath(event.file)}`);
             this.renderedLines = 1;
             return;
         }
         if (!this.canRewriteLine()) {
-            this.context.stdout.write(`${this.badgeRunning()} ${event.file}\n`);
+            this.context.stdout.write(`${this.badgeRunning()} ${formatSpecDisplayPath(event.file)}\n`);
             return;
         }
         this.renderLiveState();
@@ -285,7 +288,7 @@ class DefaultReporter {
         if (event.coverageSummary.enabled) {
             renderCoverageSummary(event.coverageSummary, event.showCoverage);
             if (event.showCoverage && event.coverageSummary.uncovered) {
-                renderCoveragePoints(event.coverageSummary.files);
+                renderCoveragePoints(event.coverageSummary.files, Boolean(event.verbose || event.showCoverageAll));
             }
         }
         renderTotals(event.stats, event);
@@ -315,7 +318,7 @@ function renderFuzzFileSummary(context, results) {
     const detail = formatTime(averageFuzzModeTime(results));
     const crashFile = firstFuzzCrashFile(results);
     const crashSuffix = crashFile != null ? ` ${chalk.dim(`-> ${crashFile}`)}` : "";
-    context.stdout.write(`${itemBadge} ${path.basename(file)} ${chalk.dim(detail)}${crashSuffix}\n`);
+    context.stdout.write(`${itemBadge} ${formatSpecDisplayPath(file)} ${chalk.dim(detail)}${crashSuffix}\n`);
     renderFailedFuzzers(groupFuzzResultsByFile(results));
 }
 function renderFuzzSummary(context, event, hasRenderedTestFiles) {
@@ -335,7 +338,7 @@ function renderFailedFuzzers(results) {
                     console.log("");
                     rendered = true;
                 }
-                console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(path.basename(modeResult.file))} ${chalk.dim("(crash)")}`);
+                console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(formatSpecDisplayPath(modeResult.file))} ${chalk.dim("(crash)")}`);
                 console.log(chalk.dim(`Mode: ${modeResult.modeName}`));
                 console.log(chalk.dim(`Runs: ${modeResult.runs} configured`));
                 console.log(chalk.dim(`Repro: ${repro}`));
@@ -413,7 +416,9 @@ function buildFuzzReproCommand(file, seed, modeName, fuzzer, runs) {
     return `ast fuzz ${file}${modeArg}${fuzzerArg} --seed ${seed}${runsArg}`;
 }
 function formatFailingSeeds(fuzzer) {
-    return (fuzzer.failures ?? []).map((failure) => String(failure.seed)).join(", ");
+    return (fuzzer.failures ?? [])
+        .map((failure) => String(failure.seed))
+        .join(", ");
 }
 function toRelativeResultPath(file) {
     const relative = path.relative(process.cwd(), path.resolve(process.cwd(), file));
@@ -422,8 +427,8 @@ function toRelativeResultPath(file) {
 function formatFuzzFailureTitle(file, name) {
     const location = findFuzzLocation(file, name);
     const suffix = location
-        ? ` (${path.basename(file)}:${location})`
-        : ` (${path.basename(file)})`;
+        ? ` (${formatSpecDisplayPath(file)}:${location})`
+        : ` (${formatSpecDisplayPath(file)})`;
     return `${chalk.dim(name)}${chalk.dim(suffix)}`;
 }
 function findFuzzLocation(file, name) {
@@ -460,19 +465,24 @@ function renderFailedSuites(failedEntries) {
     if (!failedEntries.length)
         return;
     console.log("");
-    const printed = new Set();
+    const grouped = new Map();
     for (const failed of failedEntries) {
         const failedAny = failed;
         if (!failedAny?.file)
             continue;
         const file = String(failedAny.file);
-        collectSuiteFailures(failed, file, [], printed);
+        collectSuiteFailures(failed, file, [], grouped);
+    }
+    for (const failure of grouped.values()) {
+        renderCollectedFailure(failure);
     }
 }
-function collectSuiteFailures(suite, file, path, printed, inheritedModeName = "") {
+function collectSuiteFailures(suite, file, path, grouped, inheritedModeName = "") {
     const suiteAny = suite;
     const nextPath = [...path, String(suiteAny.description ?? "unknown")];
     const modeName = String(suiteAny.modeName ?? inheritedModeName);
+    const isRuntimeErrorSuite = String(suiteAny.kind ?? "") == "runtime-error";
+    const isBuildErrorSuite = String(suiteAny.kind ?? "") == "build-error";
     const tests = Array.isArray(suiteAny.tests)
         ? suiteAny.tests
         : [];
@@ -486,30 +496,159 @@ function collectSuiteFailures(suite, file, path, printed, inheritedModeName = ""
         const where = loc.length ? `${file}:${loc}` : file;
         const suitePath = String(suiteAny.path ?? "");
         const message = String(test.message ?? "");
-        const dedupeKey = `${file}::${modeName}::${title}::${String(test.left)}::${String(test.right)}::${message}`;
-        if (printed.has(dedupeKey))
-            continue;
-        printed.add(dedupeKey);
-        console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(title)} ${chalk.dim("(" + where + ")")}`);
+        const left = test.left;
+        const right = test.right;
+        const dedupeKey = `${file}::${title}::${String(left)}::${String(right)}::${message}`;
+        let failure = grouped.get(dedupeKey);
+        if (!failure) {
+            failure = {
+                title,
+                where,
+                file,
+                suitePath,
+                left,
+                right,
+                message,
+                isRuntimeError: isRuntimeErrorSuite || String(test.type ?? "") == "runtime-error",
+                isBuildError: isBuildErrorSuite || String(test.type ?? "") == "build-error",
+                modes: new Set(),
+                runCommands: new Map(),
+                buildCommands: new Map(),
+            };
+            grouped.set(dedupeKey, failure);
+        }
         if (modeName.length) {
-            console.log(chalk.dim(`Mode: ${modeName}`));
+            failure.modes.add(modeName);
+        }
+        const runCommand = String(suiteAny.runCommand ?? "");
+        if (modeName.length && runCommand.length) {
+            failure.runCommands.set(modeName, runCommand);
         }
-        if (suitePath.length) {
-            console.log(chalk.dim(`Repro: ${buildSuiteReproCommand(toRelativeResultPath(file), suitePath, modeName)}`));
+        const buildCommand = String(suiteAny.buildCommand ?? "");
+        if (modeName.length && buildCommand.length) {
+            failure.buildCommands.set(modeName, buildCommand);
         }
-        renderAssertionFailureDetails(test.left, test.right, message);
     }
     const suites = Array.isArray(suiteAny.suites)
         ? suiteAny.suites
         : [];
     for (const sub of suites) {
-        collectSuiteFailures(sub, file, nextPath, printed, modeName);
+        collectSuiteFailures(sub, file, nextPath, grouped, modeName);
+    }
+}
+function renderCollectedFailure(failure) {
+    console.log(`${chalk.bgRed(" FAIL ")} ${chalk.dim(failure.title)} ${chalk.dim("(" + failure.where + ")")}`);
+    const modes = [...failure.modes].filter(Boolean).sort();
+    if (failure.isBuildError) {
+        renderBuildFailureDetails(failure, modes);
+    }
+    else if (failure.isRuntimeError) {
+        renderRuntimeFailureDetails(failure, modes);
+    }
+    else {
+        if (modes.length == 1) {
+            console.log(chalk.dim(`Mode: ${modes[0]}`));
+        }
+        else if (modes.length > 1) {
+            console.log(chalk.dim(`Modes: ${modes.join(", ")}`));
+        }
+        const relativeFile = toRelativeResultPath(failure.file);
+        const repro = failure.suitePath.length && modes.length == 1
+            ? buildSuiteReproCommand(relativeFile, failure.suitePath, modes[0])
+            : buildFileReproCommand(relativeFile, modes);
+        console.log(chalk.dim(`Repro: ${repro}`));
+        renderModeCommands("Build", failure.buildCommands, modes);
+        renderModeCommands("Run", failure.runCommands, modes);
+    }
+    renderAssertionFailureDetails(failure.left, failure.right, failure.message);
+}
+function renderBuildFailureDetails(failure, modes) {
+    console.log("");
+    console.log(chalk.bold(" Oops! Looks like the test failed to build!"));
+    console.log(chalk.dim(" Here's some details and reproduction instructions if that helps:"));
+    console.log("");
+    console.log(chalk.dim(` Mode(s): ${modes.join(", ") || "default"}`));
+    console.log("");
+    console.log(chalk.dim(" To reproduce, run the following commands:"));
+    for (const mode of modes.length ? modes : ["default"]) {
+        console.log(chalk.dim(` Mode: ${mode}`));
+        const buildCommand = failure.buildCommands.get(mode);
+        if (buildCommand?.length) {
+            console.log(chalk.dim(`  Build: ${buildCommand}`));
+        }
+    }
+    console.log("");
+    console.log(chalk.dim(" Here's a log dump too:"));
+}
+function renderRuntimeFailureDetails(failure, modes) {
+    console.log("");
+    console.log(chalk.bold(" Oops! Looks like the runtime crashed!"));
+    console.log(chalk.dim(" Here's some details and reproduction instructions if that helps:"));
+    console.log("");
+    console.log(chalk.dim(` Mode(s): ${modes.join(", ") || "default"}`));
+    console.log("");
+    console.log(chalk.dim(" To reproduce, run the following commands:"));
+    for (const mode of modes.length ? modes : ["default"]) {
+        console.log(chalk.dim(` Mode: ${mode}`));
+        const buildCommand = failure.buildCommands.get(mode);
+        if (buildCommand?.length) {
+            console.log(chalk.dim(`  Build: ${buildCommand}`));
+        }
+        const runCommand = buildRuntimeReproRunCommand(failure.runCommands.get(mode) ?? "", buildCommand ?? "");
+        if (runCommand.length) {
+            console.log(chalk.dim(`  Run: ${runCommand}`));
+        }
     }
+    console.log("");
+    console.log(chalk.dim(" Here's a log dump too:"));
 }
 function buildSuiteReproCommand(file, suitePath, modeName) {
     const modeArg = modeName && modeName != "default" ? ` --mode ${modeName}` : "";
     return `ast run ${file}${modeArg} --suite ${suitePath}`;
 }
+function buildFileReproCommand(file, modes) {
+    const normalizedModes = modes.filter(Boolean).sort();
+    if (normalizedModes.length == 1 && normalizedModes[0] != "default") {
+        return `ast run ${file} --mode ${normalizedModes[0]}`;
+    }
+    if (normalizedModes.length > 1 &&
+        normalizedModes.every((mode) => mode != "default")) {
+        return `ast run ${file} --mode ${normalizedModes.join(",")}`;
+    }
+    return `ast run ${file}`;
+}
+function renderModeCommands(label, commands, modes) {
+    if (!commands.size)
+        return;
+    const uniqueCommands = new Set([...commands.values()].filter(Boolean));
+    if (uniqueCommands.size == 1) {
+        console.log(chalk.dim(`${label}: ${[...uniqueCommands][0]}`));
+        return;
+    }
+    console.log(chalk.dim(`${label} commands:`));
+    for (const mode of modes) {
+        const command = commands.get(mode);
+        if (!command)
+            continue;
+        console.log(chalk.dim(`  [${mode}] ${command}`));
+    }
+}
+function buildRuntimeReproRunCommand(runCommand, buildCommand) {
+    if (!runCommand.length)
+        return "";
+    const artifactPath = extractBuildArtifactPath(buildCommand);
+    if (!artifactPath) {
+        return runCommand;
+    }
+    if (runCommand.includes(".as-test/runners/default.")) {
+        return `${runCommand} ${artifactPath}`;
+    }
+    return runCommand;
+}
+function extractBuildArtifactPath(buildCommand) {
+    const outMatch = buildCommand.match(/(?:^|\s)(?:-o|--outFile)\s+(?:"([^"]+)"|'([^']+)'|(\S+))/);
+    return outMatch?.[1] ?? outMatch?.[2] ?? outMatch?.[3] ?? null;
+}
 function normalizeFailureMessage(message) {
     return message.replace(/\r\n/g, "\n").trim();
 }
@@ -520,11 +659,13 @@ function renderAssertionFailureDetails(leftRaw, rightRaw, messageRaw) {
     if (left == "null" && right == "null") {
         const normalizedMessage = normalizeFailureMessage(message);
         if (normalizedMessage.length) {
+            console.log("");
             for (const line of normalizedMessage.split("\n")) {
                 console.log(chalk.dim(line));
             }
         }
         else {
+            console.log("");
             console.log(chalk.dim("runtime error"));
         }
         return;
@@ -656,7 +797,9 @@ function renderCoverageSummary(summary, showCoverage) {
     const pct = summary.total
         ? ((summary.covered * 100) / summary.total).toFixed(2)
         : "100.00";
-    const missingLabel = summary.uncovered == 1 ? "1 point missing" : `${summary.uncovered} points missing`;
+    const missingLabel = summary.uncovered == 1
+        ? "1 point missing"
+        : `${summary.uncovered} points missing`;
     const fileLabel = summary.files.length == 1 ? "1 file" : `${summary.files.length} files`;
     const color = Number(pct) >= 90
         ? chalk.greenBright
@@ -681,16 +824,14 @@ function renderCoverageSummary(summary, showCoverage) {
             : Number(filePct) >= 75
                 ? chalk.yellowBright
                 : chalk.redBright;
-        const suffix = file.uncovered > 0
-            ? `${file.uncovered} missing`
-            : "fully covered";
+        const suffix = file.uncovered > 0 ? `${file.uncovered} missing` : "fully covered";
         console.log(`    ${fileColor(filePct.padStart(6) + "%")}  ${toRelativeResultPath(file.file).padEnd(36)} ${chalk.dim(`${file.covered}/${file.total} covered, ${suffix}`)}`);
     }
     if (ranked.length > 8) {
         console.log(chalk.dim(`    ... ${ranked.length - 8} more files`));
     }
 }
-function renderCoveragePoints(files) {
+function renderCoveragePoints(files, expandNested) {
     console.log("");
     console.log(chalk.bold("Coverage Gaps"));
     const sortedFiles = [...files].sort((a, b) => a.file.localeCompare(b.file));
@@ -701,28 +842,124 @@ function renderCoveragePoints(files) {
         displayType: describeCoveragePoint(point.file, point.line, point.column, point.type).displayType,
     })));
     const layout = createCoverageGapLayout(missingPoints);
+    let renderedFileCount = 0;
+    let collapsedNestedPoints = 0;
     for (const file of sortedFiles) {
-        const points = [...file.points].sort((a, b) => {
-            if (a.line != b.line)
-                return a.line - b.line;
-            if (a.column != b.column)
-                return a.column - b.column;
-            return a.type.localeCompare(b.type);
-        });
+        const points = [...file.points].sort(compareCoverageGapPoints);
         const missing = points.filter((point) => !point.executed);
         if (!missing.length)
             continue;
+        if (renderedFileCount > 0) {
+            console.log("");
+        }
         console.log(`  ${chalk.bold(toRelativeResultPath(file.file))} ${chalk.dim(`(${missing.length} uncovered)`)}`);
+        const pointsByHash = new Map(points.map((point) => [point.hash, point]));
+        const childrenByParent = new Map();
+        const roots = [];
         for (const point of points) {
-            if (point.executed)
-                continue;
-            const location = `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`;
-            const snippet = formatCoverageSnippet(point.file, point.line, point.column);
-            const typeLabel = describeCoveragePoint(point.file, point.line, point.column, point.type).displayType.padEnd(layout.typeWidth + 4);
-            const locationLabel = location.padEnd(layout.locationWidth + 4);
-            console.log(`    ${chalk.red("x")} ${chalk.dim(typeLabel)}${chalk.dim(locationLabel)}${snippet}`);
+            const parentHash = point.parentHash ?? "";
+            if (parentHash.length && pointsByHash.has(parentHash)) {
+                const children = childrenByParent.get(parentHash) ?? [];
+                children.push(point);
+                childrenByParent.set(parentHash, children);
+            }
+            else {
+                roots.push(point);
+            }
+        }
+        const visibleRoots = roots.filter((point) => shouldRenderCoveragePoint(point, childrenByParent));
+        for (let i = 0; i < visibleRoots.length; i++) {
+            collapsedNestedPoints += renderCoveragePointTree(visibleRoots[i], childrenByParent, layout, [], i == visibleRoots.length - 1, expandNested);
+        }
+        renderedFileCount++;
+    }
+    if (!expandNested && collapsedNestedPoints > 0) {
+        console.log("");
+        console.log(chalk.dim("  Run with --show-coverage=all or --verbose to expand nested coverage gaps."));
+    }
+}
+function renderCoveragePointTree(point, childrenByParent, layout, ancestorHasNext, isLast, expandNested) {
+    const visibleChildren = [...(childrenByParent.get(point.hash) ?? [])]
+        .filter((child) => shouldRenderCoveragePoint(child, childrenByParent))
+        .sort(compareCoverageGapPoints);
+    const nestedUncoveredCount = countNestedUncoveredPoints(visibleChildren, childrenByParent);
+    if (!point.executed) {
+        renderCoverageGapLine(point, layout, ancestorHasNext, isLast);
+        if (nestedUncoveredCount > 0) {
+            if (expandNested) {
+                let rendered = 0;
+                for (let i = 0; i < visibleChildren.length; i++) {
+                    rendered += renderCoveragePointTree(visibleChildren[i], childrenByParent, layout, [...ancestorHasNext, !isLast], i == visibleChildren.length - 1, expandNested);
+                }
+                return 1 + rendered;
+            }
+            const treePrefix = buildCoverageTreePrefix([...ancestorHasNext, !isLast], true);
+            console.log(`    ${treePrefix}${chalk.dim(`(+${nestedUncoveredCount} nested uncovered point${nestedUncoveredCount == 1 ? "" : "s"})`)}`);
+            return nestedUncoveredCount;
         }
+        return 0;
+    }
+    if (nestedUncoveredCount <= 0)
+        return 0;
+    renderCoverageScopeHeader(point, layout, ancestorHasNext, isLast);
+    let rendered = 0;
+    for (let i = 0; i < visibleChildren.length; i++) {
+        rendered += renderCoveragePointTree(visibleChildren[i], childrenByParent, layout, [...ancestorHasNext, !isLast], i == visibleChildren.length - 1, expandNested);
+    }
+    return rendered;
+}
+function shouldRenderCoveragePoint(point, childrenByParent) {
+    if (!point.executed)
+        return true;
+    return (countNestedUncoveredPoints(childrenByParent.get(point.hash) ?? [], childrenByParent) > 0);
+}
+function countNestedUncoveredPoints(points, childrenByParent) {
+    let count = 0;
+    for (const point of points) {
+        if (!point.executed)
+            count++;
+        count += countNestedUncoveredPoints(childrenByParent.get(point.hash) ?? [], childrenByParent);
+    }
+    return count;
+}
+function renderCoverageGapLine(point, layout, ancestorHasNext, isLast) {
+    const location = `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`;
+    const snippet = formatCoverageSnippet(point.file, point.line, point.column, point.type, ancestorHasNext.length);
+    const typeLabel = describeCoveragePoint(point.file, point.line, point.column, point.type).displayType.padEnd(layout.typeWidth + 6);
+    const locationLabel = location.padEnd(layout.locationWidth + 6);
+    const treePrefix = buildCoverageTreePrefix(ancestorHasNext, isLast);
+    const meta = `${typeLabel}${locationLabel}`;
+    console.log(`    ${treePrefix}${chalk.dim(meta)}  ${snippet}`);
+}
+function renderCoverageScopeHeader(point, layout, ancestorHasNext, isLast) {
+    const descriptor = describeCoveragePoint(point.file, point.line, point.column, point.type);
+    const label = point.scopeKind || descriptor.displayType;
+    const location = `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`;
+    const locationLabel = location.padEnd(layout.locationWidth + 6);
+    const typeLabel = label.padEnd(layout.typeWidth + 6);
+    const snippet = formatCoverageSnippet(point.file, point.line, point.column, point.type, ancestorHasNext.length);
+    const treePrefix = buildCoverageTreePrefix(ancestorHasNext, isLast);
+    const meta = `${typeLabel}${locationLabel}`;
+    console.log(`    ${treePrefix}${chalk.dim(meta)}  ${chalk.dim(snippet)}`);
+}
+function buildCoverageTreePrefix(ancestorHasNext, isLast) {
+    let out = "";
+    for (const hasNext of ancestorHasNext) {
+        out += hasNext ? "│ " : "  ";
     }
+    out += isLast ? "└─" : "├─";
+    return chalk.dim(out);
+}
+function compareCoverageGapPoints(a, b) {
+    if (a.line != b.line)
+        return a.line - b.line;
+    if (a.column != b.column)
+        return a.column - b.column;
+    if ((a.depth ?? 0) != (b.depth ?? 0))
+        return (a.depth ?? 0) - (b.depth ?? 0);
+    if (a.type != b.type)
+        return a.type.localeCompare(b.type);
+    return a.hash.localeCompare(b.hash);
 }
 function renderCoverageBar(percent) {
     const slots = 12;
@@ -732,35 +969,29 @@ function renderCoverageBar(percent) {
 function createCoverageGapLayout(points) {
     return {
         typeWidth: Math.max(...points.map((point) => point.displayType.length), 5),
-        locationWidth: Math.max(...points.map((point) => `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`.length), 1),
+        locationWidth: Math.max(...points.map((point) => `${toRelativeResultPath(point.file)}:${point.line}:${point.column}`
+            .length), 1),
     };
 }
-function formatCoverageSnippet(file, line, column) {
-    const sourceLine = readCoverageSourceLine(file, line);
-    if (!sourceLine)
-        return "";
-    const expanded = sourceLine.replace(/\t/g, "  ");
-    const firstNonWhitespace = expanded.search(/\S/);
-    if (firstNonWhitespace == -1)
-        return "";
-    const visible = expanded.slice(firstNonWhitespace).trimEnd();
+function formatCoverageSnippet(file, line, column, fallbackType, _depth) {
+    const descriptor = describeCoveragePoint(file, line, column, fallbackType);
+    const visible = descriptor.visible;
     if (!visible.length)
         return "";
     const maxWidth = 72;
-    const focus = Math.max(0, Math.min(visible.length - 1, Math.max(0, column - 1 - firstNonWhitespace)));
+    const focus = Math.max(0, Math.min(visible.length - 1, descriptor.focus));
     if (visible.length <= maxWidth) {
-        return styleCoverageSnippetWindow(visible, 0, visible.length, focus);
+        return styleCoverageSnippetWindow(visible, 0, visible.length, focus, descriptor.highlightStart, descriptor.highlightEnd);
     }
     const start = Math.max(0, Math.min(visible.length - maxWidth, focus - Math.floor(maxWidth / 2)));
     const end = Math.min(visible.length, start + maxWidth);
-    return styleCoverageSnippetWindow(visible, start, end, focus);
+    return styleCoverageSnippetWindow(visible, start, end, focus, descriptor.highlightStart, descriptor.highlightEnd);
 }
-function styleCoverageSnippetWindow(visible, start, end, focus) {
+function styleCoverageSnippetWindow(visible, start, end, focus, highlightStart, highlightEnd) {
     const prefix = start > 0 ? "..." : "";
     const suffix = end < visible.length ? "..." : "";
     const slice = visible.slice(start, end);
     const localFocus = Math.max(0, Math.min(slice.length - 1, focus - start));
-    const [highlightStart, highlightEnd] = resolveCoverageHighlightSpan(visible, focus);
     const localStart = Math.max(0, Math.min(slice.length, highlightStart - start));
     const localEnd = Math.max(localStart + 1, Math.min(slice.length, highlightEnd - start));
     if (!slice.length)

package/bin/util.js

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from "fs";
 import { BuildOptions, Config, CoverageOptions, CoverageIgnoreOptions, FuzzConfig, ModeConfig, ReporterConfig, RunOptions, Runtime, } from "./types.js";
 import chalk from "chalk";
 import { createRequire } from "module";
-import { delimiter, dirname, join, resolve } from "path";
+import { basename, delimiter, dirname, join, relative, resolve, sep, } from "path";
 import { fileURLToPath } from "url";
 const CONFIG_META = new WeakMap();
 export function formatTime(ms) {
@@ -28,6 +28,19 @@ export function formatTime(ms) {
     }
     return `${us}us`;
 }
+export function formatSpecDisplayPath(file) {
+    const resolved = resolve(file);
+    const parts = resolved.split(/[/\\]+/);
+    const testsIndex = parts.lastIndexOf("__tests__");
+    if (testsIndex >= 0 && testsIndex < parts.length - 1) {
+        return parts.slice(testsIndex + 1).join("/");
+    }
+    const rel = relative(process.cwd(), resolved).split(sep).join("/");
+    if (rel.length && rel != "." && rel != ".." && !rel.startsWith("../")) {
+        return rel;
+    }
+    return basename(resolved);
+}
 export function loadConfig(CONFIG_PATH, warn = false) {
     const resolvedPath = resolve(CONFIG_PATH);
     const raw = readConfigRaw(resolvedPath, warn);
@@ -102,9 +115,7 @@ function parseConfigRaw(raw, configPath) {
         : "";
     const cmd = runtimeRaw && typeof runtimeRaw.cmd == "string" && runtimeRaw.cmd.length
         ? runtimeRaw.cmd
-        : runtimeRaw &&
-            typeof runtimeRaw.run == "string" &&
-            runtimeRaw.run.length
+        : runtimeRaw && typeof runtimeRaw.run == "string" && runtimeRaw.run.length
             ? runtimeRaw.run
             : legacyRun
                 ? legacyRun
@@ -343,7 +354,9 @@ function validateCoverageValue(value, path, issues) {
     validateStringArrayField(obj, "include", path, issues);
     validateStringArrayField(obj, "exclude", path, issues);
     if ("ignore" in obj && obj.ignore != undefined) {
-        if (!obj.ignore || typeof obj.ignore != "object" || Array.isArray(obj.ignore)) {
+        if (!obj.ignore ||
+            typeof obj.ignore != "object" ||
+            Array.isArray(obj.ignore)) {
             issues.push({
                 path: `${path}.ignore`,
                 message: "must be an object",
@@ -967,14 +980,19 @@ function cloneConfig(config) {
     cloned.runOptions = cloneRunOptions(config.runOptions);
     cloned.fuzz = cloneFuzzConfig(config.fuzz);
     cloned.coverage = cloneCoverageOptions(config.coverage);
-    cloned.modes = Object.fromEntries(Object.entries(config.modes).map(([name, mode]) => [name, cloneModeConfig(mode)]));
+    cloned.modes = Object.fromEntries(Object.entries(config.modes).map(([name, mode]) => [
+        name,
+        cloneModeConfig(mode),
+    ]));
     CONFIG_META.set(cloned, getConfigMeta(config));
     return cloned;
 }
 function outputOverridesField(raw, field) {
     if (field in raw)
         return true;
-    if (!raw.output || typeof raw.output != "object" || Array.isArray(raw.output)) {
+    if (!raw.output ||
+        typeof raw.output != "object" ||
+        Array.isArray(raw.output)) {
         return false;
     }
     const output = raw.output;
@@ -1023,7 +1041,9 @@ function mergeCoverageConfig(base, override, raw) {
         mergedBase.include = [...overrideOptions.include];
     if ("exclude" in rawObject)
         mergedBase.exclude = [...overrideOptions.exclude];
-    if (rawObject.ignore && typeof rawObject.ignore == "object" && !Array.isArray(rawObject.ignore)) {
+    if (rawObject.ignore &&
+        typeof rawObject.ignore == "object" &&
+        !Array.isArray(rawObject.ignore)) {
         mergedBase.ignore = mergeCoverageIgnoreOptions(mergedBase.ignore, overrideOptions.ignore, rawObject.ignore);
     }
     return mergedBase;
@@ -1068,7 +1088,8 @@ function mergeRunOptions(base, override, raw) {
     const merged = cloneRunOptions(base);
     if ("runtime" in raw || "run" in raw) {
         const runtimeRaw = raw.runtime;
-        if ("run" in raw || (runtimeRaw && ("cmd" in runtimeRaw || "run" in runtimeRaw))) {
+        if ("run" in raw ||
+            (runtimeRaw && ("cmd" in runtimeRaw || "run" in runtimeRaw))) {
             merged.runtime.cmd = override.runtime.cmd;
         }
         if (runtimeRaw && "browser" in runtimeRaw) {
@@ -1126,10 +1147,14 @@ function mergeRootConfig(base, override) {
     if ("env" in raw) {
         merged.env = { ...override.env };
     }
-    if (raw.buildOptions && typeof raw.buildOptions == "object" && !Array.isArray(raw.buildOptions)) {
+    if (raw.buildOptions &&
+        typeof raw.buildOptions == "object" &&
+        !Array.isArray(raw.buildOptions)) {
         merged.buildOptions = mergeBuildOptions(merged.buildOptions, override.buildOptions, raw.buildOptions);
     }
-    if (raw.runOptions && typeof raw.runOptions == "object" && !Array.isArray(raw.runOptions)) {
+    if (raw.runOptions &&
+        typeof raw.runOptions == "object" &&
+        !Array.isArray(raw.runOptions)) {
         merged.runOptions = mergeRunOptions(merged.runOptions, override.runOptions, raw.runOptions);
     }
     if (raw.fuzz && typeof raw.fuzz == "object" && !Array.isArray(raw.fuzz)) {