supercov 4.2.1 → 4.4.0

package/README.md

@@ -282,7 +282,7 @@ Java and Kotlin have no registry of their own here, so a JVM project takes the b
 | PHP | Coming soon | — | — |
 | C | Coming soon | — | — |
 
-The `npx` path requires Node.js 22 or newer; the other installs need no Node. Rust support currently uses Rust 1.95; cargo-nextest 0.9.138 and 0.9.140 are supported. Python support requires CPython 3.9 or newer and measures pytest and unittest runs. Ruby support requires Ruby 3.3 or newer (3.4 or newer for full measurement) and measures RSpec, Minitest, test-unit and Cucumber runs. Go support requires Go 1.22 or newer and measures `go test`. Java and Kotlin support requires a JDK 17 or newer with Maven or Gradle, and measures every JUnit Platform engine -- JUnit 5, JUnit 4 through Vintage, Kotest and Spock -- as well as TestNG.
+The `npx` path requires Node.js 22 or newer; the other installs need no Node. Rust support currently uses Rust 1.95; cargo-nextest 0.9.138 and newer are supported. Python support requires CPython 3.9 or newer and measures pytest and unittest runs. Ruby support requires Ruby 3.3 or newer (3.4 or newer for full measurement) and measures RSpec, Minitest, test-unit and Cucumber runs. Go support requires Go 1.22 or newer and measures `go test`. Java and Kotlin support requires a JDK 17 or newer with Maven or Gradle, and measures every JUnit Platform engine -- JUnit 5, JUnit 4 through Vintage, Kotest and Spock -- as well as TestNG.
 
 ## Supported operating systems and architectures
 

package/docs/assertions.md

@@ -83,9 +83,13 @@ npx supercov runs latest assertions
 ```
 
 `assertions assess` works it out and saves the result to the run. For each test,
-Supercov renders what the test ran -- its code, its helpers, and the source it
-executed -- and asks [Jev](https://typesafe.ai) whether the test would fail for
-each statement's change. It prints an estimate first; `--dry-run` sends nothing.
+Supercov renders what the test ran -- its code and the source it executed --
+and asks [Jev](https://typesafe.ai) whether the test would fail for each
+statement's change. In JavaScript, TypeScript and Python the source shown is
+the function each asked statement is in; in the other languages it is all the
+test ran in the statement's file, with the helper files the test imports. It prints an estimate first; `--dry-run` sends nothing.
+The estimate gives the first round and the most the pass can send, which is
+what it sends when no test is judged to catch anything.
 It needs a TypeSafe AI API key in `TYPESAFE_API_KEY`.
 
 `assertions` reads the saved result with no network and no key, a page at a
@@ -125,7 +129,25 @@ ones most likely written for the statement: tests whose name shares words with
 the statement's line (`corsOrigin: a false value` for
 `return corsOrigin(origin)`), and among those the tests that ran the least
 other code. A statement many tests run can still be caught by one that was
-never asked; the statement view (`assertions <file>:<line>`) says how many were.
+never asked; the statement view (`assertions <file>:<line>`) says how many were,
+and names the test files none of whose tests were asked, which is where to look
+before writing a test that may already exist.
+
+An asserted statement is a judgment too: some test was judged to fail if it
+changed, and the pass stops at the first that is. How strong that answer was
+says how far to trust it. Checked by applying each change and running the
+tests, an asserted verdict was wrong 22 times in 1,169 on an answer of 75% or
+more, and 33 times in 711 on a weaker one. The overview says how many of the
+asserted rest on a weaker answer, and `--weak` lists them:
+
+```bash
+npx supercov runs latest assertions --weak                 # the files by statements asserted on a weak answer
+npx supercov runs latest assertions src/adapters.ts --weak # those statements, the least certain first
+```
+
+What reads as covered and is not is most often a deferred effect: a flag set
+or an entry removed whose only consequence is what happens on a later event,
+run by a test that asserts on the immediate reply.
 
 ## Which tests check a change
 
@@ -140,7 +162,7 @@ Answers are kept in `.supercov/assertions/`. Each is stored under the exact text
 Jev saw for that statement and test, and reused only when a new run would ask
 the same question with the same text. Nothing decides whether a change could
 matter: a change to the statement, to code around it that the test ran, to the
-test or its helpers, or to which tests run it, asks again. A dependency or
+test, or to which tests run it, asks again. A dependency or
 configuration change asks everything again. After a typical commit only a few
 dozen questions are asked; the rest are reused.
 

package/docs/cli.md

@@ -22,6 +22,7 @@ npx supercov --help
 | Find what is not asserted in one file | `npx supercov runs latest assertions <path>` |
 | See each test's answer for one statement | `npx supercov runs latest assertions <path>:<line>` |
 | See what one test is judged to catch | `npx supercov runs latest assertions --test <name>` |
+| List what is asserted on a weak answer | `npx supercov runs latest assertions --weak` |
 | Read matching current source code | `npx supercov runs latest source <path>` |
 | Compare two runs | `npx supercov diff <older> <newer>` |
 | Open an interactive report | `npx supercov report` |
@@ -61,7 +62,8 @@ the score is arithmetic this command does over the answers. Text reports a band,
 `good`, `fair` or `weak`; `--json` carries the number and every check with what
 is known about it. `--all` includes test files, generated output and anything
 outside a source root, all of which are left out by default. `--dry-run` prints
-the exact requests and contacts nothing.
+the exact requests and contacts nothing; how many there are and what they cost
+is one line on stderr.
 
 `quality diff` reports what changed between two assessments: which files lost
 or gained health, each check that moved in them with its value before and after,
@@ -366,6 +368,19 @@ lost: 1 lines, 1 branches, 0 MC/DC conditions
 + branch src/fee.js:2 true
 ```
 
+When the difference is in more than one file, the files come first, the one
+that lost most at the top, so a component that did not render in one run reads
+as one row and not as forty:
+
+```
+in 2 files, most lost first:
+  src/panel.js: lost 6 lines, 1 branches
+  src/fee.js: lost 1 lines, 1 branches; gained 1 lines, 1 branches
+```
+
+The counts are of the whole difference, whatever page of it is shown. In
+`--json`, `files` and `byFile`.
+
 Two runs of the same code can differ a little: what an end-to-end suite
 reaches depends on timing, on the order of tests, and on state outside the
 code. When both runs measured the same source, `diff` says so under the
@@ -507,6 +522,11 @@ Merge creates a new run. The inputs must describe the same source,
 configuration, toolchain, schema, and coverage denominator. Supercov rejects an
 incompatible merge rather than publishing a misleading aggregate.
 
+`assertions assess` assesses a merged run across every suite merged into it,
+reusing the answers saved when its parts were assessed. `tests affected` is
+asked of the runs that were merged, which hold the record of what each test
+ran.
+
 ## Clean local data
 
 ```sh supercov

package/docs/coverage-model.md

@@ -176,6 +176,21 @@ without a conventional source directory is measured as a whole. Functions passed
 to compile-time style macros (`stylex.create(...)`) are left as written because
 the bundler consumes them at build time; nothing about them runs.
 
+In a Python or Ruby project every source file outside test directories,
+virtual environments and build output is measured, except what lies beside
+the package at the top of the project: `docs/`, `examples/`, benchmark
+directories (`bench/`, `benchmarks/`) and `fuzz/`. A test runs none of it, and
+counted in, a package covered to 99% reads 69%. Name one of them in
+`SUPERCOV_SOURCE_ROOTS` and it is source.
+
+In a Go module every `.go` file the toolchain compiles is measured: not
+`vendor/` or `testdata/`, not a nested module, and not a file or directory
+whose name begins with `_` or `.`, which `go build ./...` walks past. The
+programs under a top-level `examples/` are left out too. A Rust run measures
+what the build compiled, so a bench or an example `cargo test` does not build
+is listed as not compiled. A Maven or Gradle project is measured by its source
+sets: `src/main` is source, `src/test` is tests.
+
 Inside the roots, tests, fixtures, tool scripts and configuration files are
 still recognised by their path and left out. A root you name settles what it
 names: with `SUPERCOV_SOURCE_ROOTS=src,scripts` the `scripts/` directory is

package/docs/quality.md

@@ -153,6 +153,12 @@ Source roots come from your package manifests and from what they declare, so a
 Test files, generated output, tool scripts, examples, benchmarks and
 documentation are left out, each with its reason. `--all` includes everything.
 
+A JavaScript or TypeScript file a coverage run would measure is always read,
+by `quality` and by `security`: the App Router handler at
+`app/api/wordpress/test/route.ts` is a route, not a test, and a root named in
+`SUPERCOV_SOURCE_ROOTS` is not second-guessed by its own name. Generated and
+vendored files stay out.
+
 If some of your code sits somewhere none of that recognises, Supercov asks Jev
 about those paths with your whole tree as context, and says how many it decided
 that way. To decide yourself:

package/docs/security.md

@@ -183,6 +183,12 @@ many of its measured lines no test reached. A handler that builds a query from
 request input is one thing; the same handler that no test ever executes is a
 stronger claim, and one that needs both halves of this product to make.
 
+When the run's assertions were assessed (`runs <run> assertions assess`), the
+report also says which flagged lines a test is judged to catch a change to, and
+which flagged files tests run without catching any line of. A run that was not
+assessed says so instead: nobody asked its tests, which is not the same as
+their catching nothing.
+
 ## What a change introduced
 
 ```bash

package/docs/supported-suites.md

@@ -150,7 +150,7 @@ whatever was still buffered.
 | --- | --- | --- |
 | Cargo's standard libtest runner | Exact test, attempt, and passing-assertion identity | Rust 1.95; run with `npx supercov -- cargo test` |
 | rustdoc doctests | Exact doctest identity; every doctest runs in a process of its own | Rust 1.95; part of `npx supercov -- cargo test` |
-| cargo-nextest | Exact test, attempt, retry, and binary identity | cargo-nextest 0.9.138 or 0.9.140 |
+| cargo-nextest | Exact test, attempt, retry, and binary identity | cargo-nextest 0.9.138 or newer (tested with 0.9.140 and 0.9.148) |
 
 Supercov preserves Cargo's test selection, scheduling, fail-fast behavior,
 environment and exit status. Doctests run with their own identities; nextest

package/docs/troubleshooting.md

@@ -157,6 +157,13 @@ npx supercov -- sh -c "npm run build && npm test"
 A `pretest` script, or a Playwright `webServer` that builds, does the same. The
 build then compiles the instrumented copy, and what the tests run is measured.
 
+A build made in an earlier step does not reach the copy either. A CI job that
+ran `npm run build` and then `supercov -- node --test`, as a gate written for
+Supercov 3 would, built the project and tested a copy without `dist/`: the
+tests that need it fail, and the run still reports a coverage figure for the
+rest. The message at the end of such a run says the copy starts without build
+output and gives the command with the build in it.
+
 ## A test that reads your source fails under Supercov
 
 A test that opens your source files and asserts on their text sees the probes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "4.2.1",
+  "version": "4.4.0",
   "description": "Coverage, security and code quality for coding agents",
   "keywords": [
     "coverage",
@@ -82,7 +82,7 @@
     "eval:skill": "claude plugin eval plugins/supercov --scaffold --trust-plugin --no-publish --model claude-sonnet-5 --judge-model claude-haiku-4-5 --threshold 0.66 --tag behavior trigger --allow-tools Bash Edit Write --max-cost-usd 15",
     "eval:skill-triggers": "claude plugin eval plugins/supercov --scaffold --trust-plugin --no-publish --model claude-sonnet-5 --judge-model claude-haiku-4-5 --threshold 0.66 --tag trigger --ablation none --max-cost-usd 5",
     "test:engine": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && cargo test --workspace && npm run test:runtime && npm run test:rust-assets && npm run test:engine-integrations",
-    "test:engine-integrations": "cargo build -p supercov && node scripts/html-report-integration.mjs && node scripts/rust-process-supervision.mjs && node scripts/rust-direct-node-integration.mjs && node scripts/rust-public-run-integration.mjs && node scripts/rust-embedded-runtime-integration.mjs && node scripts/rust-direct-vitest-integration.mjs && node scripts/rust-direct-jest-integration.mjs && node scripts/rust-direct-playwright-integration.mjs && node scripts/rust-custom-browser-playwright-integration.mjs && node scripts/rust-classic-browser-integration.mjs && node scripts/rust-top-packages-integration.mjs && node scripts/rust-generic-esbuild-integration.mjs && node scripts/rust-generic-tsc-integration.mjs && node scripts/rust-generic-build-matrix.mjs && node scripts/rust-vite-playwright-integration.mjs",
+    "test:engine-integrations": "cargo build -p supercov && node scripts/html-report-integration.mjs && node scripts/rust-process-supervision.mjs && node scripts/rust-direct-node-integration.mjs && node scripts/rust-public-run-integration.mjs && node scripts/rust-embedded-runtime-integration.mjs && node scripts/rust-direct-vitest-integration.mjs && node scripts/rust-direct-jest-integration.mjs && node scripts/mocha-failure-output.mjs && node scripts/failure-output.mjs node ava tap && node scripts/rust-direct-playwright-integration.mjs && node scripts/rust-custom-browser-playwright-integration.mjs && node scripts/rust-classic-browser-integration.mjs && node scripts/rust-top-packages-integration.mjs && node scripts/rust-generic-esbuild-integration.mjs && node scripts/rust-generic-tsc-integration.mjs && node scripts/rust-generic-build-matrix.mjs && node scripts/rust-vite-playwright-integration.mjs",
     "test:platform": "cargo test --workspace && cargo build -p supercov && node scripts/rust-process-supervision.mjs && node scripts/workspace-crash-integration.mjs",
     "test:native-package": "cargo build --release -p supercov && node scripts/native-package-integration.mjs && node scripts/native-release-set-integration.mjs",
     "test:pypi-wheel": "node scripts/pypi-wheel-integration.mjs",
@@ -104,11 +104,11 @@
     "prepublishOnly": "npm run release:check",
     "test:child-attribution": "cargo build -p supercov && node scripts/rust-child-attribution-integration.mjs",
     "test:host-loader": "cargo build -p supercov && node scripts/rust-host-loader-integration.mjs",
-    "test:python": "cargo build -p supercov && node scripts/python-integration.mjs",
-    "test:ruby-coverage": "cargo build -p supercov && node scripts/ruby-coverage-integration.mjs",
-    "test:go": "cargo test --no-fail-fast -p supercov-engine --test go_frontend --test go_run",
+    "test:python": "cargo build -p supercov && node scripts/python-integration.mjs && node scripts/failure-output.mjs python",
+    "test:ruby-coverage": "cargo build -p supercov && node scripts/ruby-coverage-integration.mjs && node scripts/failure-output.mjs ruby",
+    "test:go": "cargo test --no-fail-fast -p supercov-engine --test go_frontend --test go_run && cargo build -p supercov && node scripts/failure-output.mjs go",
     "test:jvm": "cargo test --no-fail-fast -p supercov-engine --test jvm_frontend --test jvm_run -- --include-ignored --test-threads=1",
-    "test:rust-public-cargo": "cargo build -p supercov && node scripts/rust-public-cargo-integration.mjs",
+    "test:rust-public-cargo": "cargo build -p supercov && node scripts/rust-public-cargo-integration.mjs && node scripts/failure-output.mjs rust",
     "test:assertions": "cargo build -p supercov && node scripts/assertions-integration.mjs",
     "docs:sync": "node scripts/sync-docs.mjs",
     "docs:check": "node scripts/sync-docs.mjs --check",
@@ -119,14 +119,14 @@
     "test:windows-tls": "node scripts/windows-tls-test.mjs"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "4.2.1",
-    "@supercov/cli-darwin-x64": "4.2.1",
-    "@supercov/cli-linux-arm64-gnu": "4.2.1",
-    "@supercov/cli-linux-arm64-musl": "4.2.1",
-    "@supercov/cli-linux-x64-gnu": "4.2.1",
-    "@supercov/cli-linux-x64-musl": "4.2.1",
-    "@supercov/cli-win32-arm64": "4.2.1",
-    "@supercov/cli-win32-x64": "4.2.1"
+    "@supercov/cli-darwin-arm64": "4.4.0",
+    "@supercov/cli-darwin-x64": "4.4.0",
+    "@supercov/cli-linux-arm64-gnu": "4.4.0",
+    "@supercov/cli-linux-arm64-musl": "4.4.0",
+    "@supercov/cli-linux-x64-gnu": "4.4.0",
+    "@supercov/cli-linux-x64-musl": "4.4.0",
+    "@supercov/cli-win32-arm64": "4.4.0",
+    "@supercov/cli-win32-x64": "4.4.0"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",

package/runtime/javascript/ava.mjs

@@ -11,7 +11,7 @@ import { realpathSync } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { beginBufferedServerEvidence, flushBufferedServerEvidence, takeNodeAssertionPhases, withCoverageCarrier, } from "./runtime.mjs";
-import { runnerExecutionScope, writeRunnerEvidence } from "./runnerEvidence.mjs";
+import { runnerExecutionScope, stackAsWritten, writeRunnerEvidence } from "./runnerEvidence.mjs";
 
 // The installed ava package the entrypoint belongs to.
 function avaRoot(entrypoint) {
@@ -26,6 +26,24 @@ function avaRoot(entrypoint) {
     return at < 0 ? undefined : real.slice(0, at + "/node_modules/ava".length);
 }
 
+function asWritten(failure, depth = 0) {
+    if (!failure || typeof failure !== "object" || depth > 4)
+        return;
+    try {
+        // AVA prints the stack of an error a test threw as it is, and
+        // shortens a failed assertion's by its own working directory, which
+        // is the copy. A thrown error reaches here as an assertion's cause.
+        const shortened = failure.type === "ava" && !(failure.originalError?.cause instanceof Error);
+        if (typeof failure.stack === "string")
+            failure.stack = stackAsWritten(failure.stack, shortened);
+        for (const inner of Array.isArray(failure.errors) ? failure.errors : [])
+            asWritten(inner, depth + 1);
+    }
+    catch {
+        // A stack that cannot be written is printed as it is.
+    }
+}
+
 export async function adaptAva(entrypoint) {
     const evidenceDirectory = process.env.SUPERCOV_EVIDENCE_DIR;
     const root = avaRoot(entrypoint);
@@ -66,6 +84,20 @@ export async function adaptAva(entrypoint) {
         });
     };
     Runner.prototype.runTest.supercovAva = true;
+    // AVA prints a failure's stack as it is. The test ran in the copy, so a
+    // frame of the test file named it there, and a frame of a rewritten
+    // module was named by its path where Node names a module by its URL:
+    // `at seal (/home/me/shop/src/crypto.js:3:11)` over
+    // `at file:///home/me/shop/.supercov/workspaces/…/test/crypto.test.js:5:18`.
+    // A failure is told to the reporter as a state change; its stack is put
+    // right on the way.
+    const emit = Runner.prototype.emit;
+    if (typeof emit === "function")
+        Runner.prototype.emit = function supercovAvaEmit(name, data, ...rest) {
+            if (name === "stateChange" && data?.err)
+                asWritten(data.err);
+            return Reflect.apply(emit, this, [name, data, ...rest]);
+        };
     // A skipped or todo test never reaches runTest; AVA announces it.
     const start = Runner.prototype.start;
     if (typeof start === "function")

package/runtime/javascript/mocha.mjs

@@ -64,6 +64,52 @@ export async function adaptMocha(entrypoint) {
         return Reflect.apply(run, this, args);
     };
     Runner.prototype.run.supercovMocha = true;
+    // Mocha takes its working directory off the front of each frame and
+    // prints the rest. Under Supercov that is the copy, while an application
+    // frame names the project's own file, so it printed whole:
+    // `at seal (/home/me/shop/src/crypto.js:3:11)` for `src/crypto.js:3:11`.
+    // And Supercov's hooks into asynchronous work put a frame of Node's under
+    // every stack that starts in a timer. A failure reads as it does without
+    // Supercov before Mocha or a reporter sees it.
+    const fail = Runner.prototype.fail;
+    if (typeof fail === "function") {
+        const place = asWritten();
+        Runner.prototype.fail = function supercovMochaFail(runnable, error, ...rest) {
+            place(error);
+            return Reflect.apply(fail, this, [runnable, error, ...rest]);
+        };
+    }
+}
+
+const HOOK_FRAME = /^\s*at process\.(?:callbackTrampoline|topLevelDomainCallback) \(node:(?:internal\/async_hooks|domain):\d+:\d+\)$/;
+
+function asWritten() {
+    const real = (directory) => {
+        try {
+            return directory ? realpathSync(directory) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const project = real(process.env.SUPERCOV_SOURCE_PROJECT_ROOT);
+    const copy = real(process.env.SUPERCOV_PROJECT_ROOT);
+    return (error) => {
+        if (!error || typeof error.stack !== "string")
+            return;
+        const lines = error.stack.split("\n").filter((line) => !HOOK_FRAME.test(line));
+        const placed = project && copy && project !== copy
+            ? lines.map((line) => /^\s*at /.test(line) && line.includes(project + sep) && !line.includes(copy + sep)
+                ? line.replace(`(${project}${sep}`, `(${copy}${sep}`).replace(` at ${project}${sep}`, ` at ${copy}${sep}`)
+                : line)
+            : lines;
+        try {
+            error.stack = placed.join("\n");
+        }
+        catch {
+            // A stack that cannot be written is printed as it is.
+        }
+    };
 }
 
 function observe(runner, runtime, write) {

package/runtime/javascript/nodeTest.mjs

@@ -2,8 +2,8 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import * as native from "node:test";
 import { fileURLToPath } from "node:url";
 import vm from "node:vm";
-import { beginBufferedServerEvidence, flushBufferedServerEvidence, takeNodeAssertionPhases, withCoverageCarrier, } from "./runtime.mjs";
-import { callerLocation, runnerExecutionScope, runnerTestId, writeRunnerEvidence, } from "./runnerEvidence.mjs";
+import { beginBufferedServerEvidence, flushBufferedServerEvidence, takeNodeAssertionPhases, withCoverageCarrier, withStackRoom, } from "./runtime.mjs";
+import { callerLocation, runnerExecutionScope, runnerTestId, stackAsWritten, writeRunnerEvidence, } from "./runnerEvidence.mjs";
 function callbackIndex(args) {
     for (let index = args.length - 1; index >= 0; index -= 1)
         if (typeof args[index] === "function")
@@ -65,11 +65,7 @@ function restoreUserError(error, depth = 0) {
         : text;
     try {
         if (typeof error.stack === "string")
-            error.stack = remap(error.stack
-                .split("\n")
-                .filter((line) => !(line.trimStart().startsWith("at ") &&
-                line.includes("/.supercov/")))
-                .join("\n"));
+            error.stack = stackAsWritten(error.stack);
         if (typeof error.message === "string")
             error.message = remap(error.message);
     }
@@ -227,9 +223,9 @@ function wrappedRegistration(original, parentTestId, forcedStatus) {
                         finishBody();
                         done?.(error);
                     };
-                    return withCoverageCarrier({ version: 1, scope }, () => Reflect.apply(callback, callbackThis, [contextProxy, callbackDone]));
+                    return withStackRoom(() => withCoverageCarrier({ version: 1, scope }, () => Reflect.apply(callback, callbackThis, [contextProxy, callbackDone])));
                 }
-                const result = withCoverageCarrier({ version: 1, scope }, () => Reflect.apply(callback, callbackThis, [contextProxy]));
+                const result = withStackRoom(() => withCoverageCarrier({ version: 1, scope }, () => Reflect.apply(callback, callbackThis, [contextProxy])));
                 if (result && typeof result.then === "function")
                     return Promise.resolve(result).then((value) => {
                         finishBody();

package/runtime/javascript/register.mjs

@@ -250,6 +250,14 @@ process.__SUPERCOV_FAILURE_OUTPUT__ ??= function supercovFailureOutput(runner) {
         // name the copy's file, and coverage reports it by its path in the
         // project's layout.
         vitest: { prints: /[\\/]vitest[\\/]dist[\\/]/, names: true },
+        // A test's process makes each frame's path relative to where it
+        // runs (@tapjs/stack), and the process that reports reads the file
+        // under a frame by that path to print it (prismjs-terminal, for
+        // @tapjs/reporter): `../../../../src/crypto.js` over the right
+        // lines, or `src/crypto.js` over Supercov's.
+        // libtap, which tap 16 and older print with, reads the file itself,
+        // and their reporter reads it through cardinal.
+        tap: { prints: /[\\/](?:@tapjs[\\/](?:stack|reporter)|prismjs-terminal|libtap|cardinal)[\\/]/, names: false },
     }[runner];
     // Asked with no runner, the reads are in place and change nothing until
     // one is named: a process that may yet run a suite.
@@ -288,9 +296,11 @@ process.__SUPERCOV_FAILURE_OUTPUT__ ??= function supercovFailureOutput(runner) {
                 rewritten = new Set();
             }
         }
+        // ts-node names a file with forward slashes on Windows too.
+        const named = sep === "\\" ? file.split("/").join(sep) : file;
         for (const root of roots) {
-            if (file.startsWith(root)) {
-                const local = file.slice(root.length).split(sep).join("/");
+            if (named.startsWith(root)) {
+                const local = named.slice(root.length).split(sep).join("/");
                 return rewritten.has(local) ? local : undefined;
             }
         }
@@ -437,7 +447,8 @@ process.__SUPERCOV_FAILURE_OUTPUT__ ??= function supercovFailureOutput(runner) {
     function supercovReadFileSync(file, ...rest) {
         if (!failureOutput.prints)
             return Reflect.apply(readSync, this, [file, ...rest]);
-        const local = rewrittenUnder(copies, file);
+        // A printer may name the file from where it runs.
+        const local = rewrittenUnder(copies, typeof file === "string" && !isAbsolute(file) ? resolve(file) : file);
         if (local === undefined) {
             const contents = Reflect.apply(readSync, this, [file, ...rest]);
             return failureOutput.composes && typeof contents === "string" && typeof file === "string" && file.endsWith(".map")
@@ -478,7 +489,61 @@ process.__SUPERCOV_FAILURE_OUTPUT__ ??= function supercovFailureOutput(runner) {
     }
     path.relative = supercovRelative;
     syncBuiltinESMExports();
+    // ts-node compiles the text it is given, which is the rewritten file,
+    // and its source map ends there: TypeScript reads no map in its input.
+    // A frame under Mocha read `src/crypto.ts:37:10` for line 8, and a test
+    // file's `:15:172` for column 12. ts-node keeps what it compiled in
+    // memory and has source-map-support read it from there, so that is
+    // where the map is carried on to the lines the author wrote: a handler
+    // of Supercov's in the list the library keeps on the global object,
+    // asked before its default.
+    const shared = Symbol.for("source-map-support/sharedData");
+    function supercovRetrieveSourceMap(source) {
+        try {
+            const file = typeof source === "string" && source.startsWith("file://") ? fileURLToPath(source) : source;
+            if (rewrittenUnder(copies, file) === undefined)
+                return null;
+            let code;
+            for (const read of globalThis[shared]?.retrieveFileHandlers ?? []) {
+                code = read(file);
+                if (code)
+                    break;
+            }
+            const found = typeof code === "string" ? code.lastIndexOf("//# sourceMappingURL=data:application/json") : -1;
+            if (found < 0)
+                return null;
+            const text = Buffer.from(code.slice(code.indexOf(",", found) + 1).trim(), "base64").toString("utf8");
+            const through = composed(text);
+            return through === text ? null : { url: source, map: through };
+        }
+        catch {
+            return null;
+        }
+    }
+    failureOutput.adopt = () => {
+        const handlers = globalThis[shared]?.retrieveMapHandlers;
+        if (Array.isArray(handlers) && !handlers.includes(supercovRetrieveSourceMap))
+            handlers.unshift(supercovRetrieveSourceMap);
+    };
+    failureOutput.adopt();
 };
+// source-map-support is ts-node's, loaded when ts-node is: by a runner's own
+// `--require`, after this file, or by Node's, before it.
+{
+    const adopt = () => {
+        process.__SUPERCOV_FAILURE_OUTPUT__();
+        failureOutput.adopt?.();
+    };
+    if (globalThis[Symbol.for("source-map-support/sharedData")])
+        adopt();
+    const load = Module._load;
+    Module._load = function supercovSourceMapSupportLoad(request, ...rest) {
+        const loaded = Reflect.apply(load, this, [request, ...rest]);
+        if (typeof request === "string" && request.includes("source-map-support"))
+            adopt();
+        return loaded;
+    };
+}
 // Jest itself prints from here on. Any other process is Jest's from the
 // moment it loads Jest: a worker of its, or a tool that runs Jest in its own
 // process (`require("jest").run()`, as react-scripts and Vue's CLI do), where
@@ -487,6 +552,9 @@ process.__SUPERCOV_FAILURE_OUTPUT__ ??= function supercovFailureOutput(runner) {
 // of process) never loads it.
 if (isJestEntrypoint)
     process.__SUPERCOV_FAILURE_OUTPUT__("jest");
+// tap prints from the process its command starts, and from each test's own.
+else if (process.env.TAP_CHILD_ID || /\/node_modules\/(?:\.bin\/tap$|tap\/|@tapjs\/run\/)/.test(entrypoint))
+    process.__SUPERCOV_FAILURE_OUTPUT__("tap");
 else {
     const jest = /(?:^|[\\/])(?:jest|jest-cli|@jest[\\/]core|jest-runner)(?:[\\/]|$)/;
     const load = Module._load;

package/runtime/javascript/runnerEvidence.mjs

@@ -1,7 +1,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import { readFileSync } from "node:fs";
-import { relative, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { appendEvidenceRecord } from "./atomic.mjs";
 import { inferTestProvenance } from "./provenance.mjs";
 import { serverEvidencePath } from "./transport.mjs";
@@ -133,3 +133,78 @@ export function writeRunnerEvidence(identity, status, scope, evidenceDirectoryOv
     };
     appendEvidenceRecord(resolve(process.cwd(), evidenceDirectory), identity.runner.replace(/[^A-Za-z0-9_-]/g, "_"), payload);
 }
+
+// A failing test's stack as its author would have seen it, for the runners
+// that print a stack as it is (node:test, AVA).
+//
+// - A frame of Supercov's is one in a file of its own, straight under a
+//   `.supercov` directory or its `node_modules`. The copy lies under a
+//   `.supercov` directory too, and every frame in it was once dropped for
+//   that: a failing node:test test printed no frame of its own file.
+//   `AsyncLocalStorage.run` is Node's frame for running a test under
+//   Supercov, and goes with the frames around it.
+// - The test ran in the copy, and a frame of a test file named it there.
+// - Node names a module's file by its URL and a CommonJS file by its path.
+//   A rewritten file is named through its source map, by path either way:
+//   `at seal (/home/me/shop/src/crypto.js:3:11)` for `file:///home/…`.
+// - What is left is cut to the length the author's limit allows; the
+//   runtime made room for its own frames while they were on the stack.
+const OWN_FRAME = /[\\/]\.supercov[\\/](?:node_modules[\\/])?[^\\/:]+\.[cm]?js:\d+/u;
+const CARRIER_FRAME = /^\s*at AsyncLocalStorage\.run \(node:internal\//u;
+const FRAME_PATH = /^(\s*at (?:.*? \()?)((?:\/|[A-Za-z]:[\\/])[^()]*?)(:\d+:\d+\)?)$/u;
+const packageTypes = new Map();
+function loadedAsModule(file) {
+    if (/\.m[jt]sx?$/u.test(file))
+        return true;
+    if (/\.c[jt]sx?$/u.test(file))
+        return false;
+    const visited = [];
+    let directory = dirname(file);
+    let type;
+    for (;;) {
+        if (packageTypes.has(directory)) {
+            type = packageTypes.get(directory);
+            break;
+        }
+        visited.push(directory);
+        try {
+            type = JSON.parse(readFileSync(resolve(directory, "package.json"), "utf8")).type === "module";
+            break;
+        }
+        catch {
+            // No manifest here, or not one that parses: the next directory up.
+        }
+        const parent = dirname(directory);
+        if (parent === directory) {
+            type = false;
+            break;
+        }
+        directory = parent;
+    }
+    for (const seen of visited)
+        packageTypes.set(seen, type);
+    return type;
+}
+//
+// `whereItRan` leaves each file where the stack has it: for a printer that
+// takes its working directory off a frame itself, and would not know the
+// project's.
+export function stackAsWritten(stack, whereItRan = false) {
+    const copy = process.env["SUPERCOV_PROJECT_ROOT"];
+    const project = whereItRan ? undefined : process.env["SUPERCOV_SOURCE_PROJECT_ROOT"];
+    const placed = (text) => copy && project && copy !== project ? text.split(copy).join(project) : text;
+    const lines = stack.split("\n");
+    const own = lines.map((line) => /^\s*at /u.test(line) && OWN_FRAME.test(line));
+    const limit = Error.stackTraceLimit;
+    let frames = 0;
+    return lines
+        .filter((line, index) => !own[index] && !(CARRIER_FRAME.test(line) && (own[index - 1] || own[index + 1])))
+        .map((line) => {
+        const frame = FRAME_PATH.exec(placed(line));
+        if (!frame || !project || !isAbsolute(frame[2]) || !frame[2].startsWith(project + sep) || !loadedAsModule(frame[2]))
+            return placed(line);
+        return `${frame[1]}${pathToFileURL(frame[2]).href}${frame[3]}`;
+    })
+        .filter((line) => !/^\s*at /u.test(line) || typeof limit !== "number" || !Number.isFinite(limit) || ++frames <= limit)
+        .join("\n");
+}

package/runtime/javascript/runtime.mjs

@@ -892,31 +892,92 @@ const INSTRUMENTATION_FRAME = /[\\/]\.supercov[\\/](?:node_modules[\\/])?(?:play
 // added, at the assertion, and below the runtime's frames the function the
 // author wrote, at the wrapper. Vitest printed both, `:12:35` and `:12:1`.
 // They are one frame again: the author's function, where the assertion is.
+//
+// The runtime's frames are not always one run. `node:assert` called through
+// its module is wrapped a second time, so an assertion that fails there has
+// frames of the runtime above the added function too, and Node's own frame
+// for `AsyncLocalStorage.run` lies among those below it: Mocha printed the
+// added function, that frame and the author's function, three for one.
+const NODE_FRAME = /^\s*at .*\(?node:internal\//u;
+const CARRIER_FRAME = /^\s*at AsyncLocalStorage\.run \(node:internal\//u;
+// An error keeps as many frames as `Error.stackTraceLimit` says, ten unless
+// someone changed it, counted from where it was made. The runtime's frames
+// were counted among them, so the author's own fell off the end: a failed
+// `node:assert` under node:test kept the function Supercov added and lost
+// the test's, and a test's stack lost the runner's frames below it. While
+// the runtime's frames are on the stack there is room for them, and what is
+// left when they are taken out is cut to the length the author asked for.
+const OWN_ROOM = 24;
+function withStackRoom(callback) {
+  const limit = Error.stackTraceLimit;
+  if (typeof limit !== "number" || !Number.isFinite(limit) || limit <= 0)
+    return callback();
+  Error.stackTraceLimit = limit + OWN_ROOM;
+  try {
+    return callback();
+  } finally {
+    // Unless the code it ran set a limit of its own.
+    if (Error.stackTraceLimit === limit + OWN_ROOM)
+      Error.stackTraceLimit = limit;
+  }
+}
+function withinStackLimit(lines) {
+  const limit = Error.stackTraceLimit;
+  if (typeof limit !== "number" || !Number.isFinite(limit) || limit < 0)
+    return lines;
+  let frames = 0;
+  return lines.filter((line) => !/^\s*at /.test(line) || ++frames <= limit);
+}
 function cleanInstrumentationStack(error, lexical = false) {
   if (!error || typeof error !== "object" || typeof error.stack !== "string")
     return error;
   const lines = error.stack.split("\n");
   const hidden = lines.map((line, index) => index > 0 && INSTRUMENTATION_FRAME.test(line));
-  const first = hidden.indexOf(true);
-  if (first < 0)
+  if (!hidden.includes(true))
     return error;
-  const last = hidden.lastIndexOf(true);
-  let visible;
   const frame = /^(\s*at (?:async )?)(?:(.*?) \()?(.*?:\d+:\d+)\)?$/;
-  const added = lexical && first > 1 ? frame.exec(lines[first - 1]) : null;
-  const written = added && last + 1 < lines.length ? frame.exec(lines[last + 1]) : null;
   const file = (location) => location.replace(/:\d+:\d+$/, "");
-  // Both are frames of the author's file, or the error is another's. A name
-  // on the added one comes from a source map (Jest names a frame by what is
-  // called at its position), and it is the name the author's line would have.
-  if (added && written && file(added[3]) === file(written[3])) {
-    const merged = added[2] !== void 0 || written[2] === void 0 ? lines[first - 1] : `${written[1]}${written[2]} (${added[3]})`;
-    visible = [...lines.slice(0, first - 1), merged, ...lines.slice(last + 2)];
-  } else {
-    visible = lines.filter((line, index) => !hidden[index]);
-  }
+  // The function Supercov added is the frame above a run of the runtime's
+  // that ends at a frame of the same file: the author's.
+  let merged;
+  let at = -1;
+  for (let start = 2; lexical && !merged && start < lines.length; start += 1) {
+    if (!hidden[start] || hidden[start - 1])
+      continue;
+    let last = start;
+    for (let index = start; index < lines.length && (hidden[index] || NODE_FRAME.test(lines[index])); index += 1) {
+      if (hidden[index])
+        last = index;
+    }
+    const added = frame.exec(lines[start - 1]);
+    const written = last + 1 < lines.length ? frame.exec(lines[last + 1]) : null;
+    // Both are frames of the author's file, or the error is another's. A name
+    // on the added one comes from a source map (Jest names a frame by what is
+    // called at its position), and it is the name the author's line would
+    // have; the function Supercov added has none of its own.
+    if (added && written && file(added[3]) === file(written[3])) {
+      const named = added[2] !== void 0 && added[2] !== "<anonymous>";
+      at = start - 1;
+      merged = {
+        last: last + 1,
+        text: named || written[2] === void 0 ? lines[at] : `${written[1]}${written[2]} (${added[3]})`
+      };
+    }
+    start = last;
+  }
+  const visible = lines.flatMap((line, index) => {
+    if (merged && index === at)
+      return [merged.text];
+    if (merged && index > at && index <= merged.last)
+      return [];
+    // Node's frame for running code under Supercov goes with the runtime's
+    // frames around it.
+    if (CARRIER_FRAME.test(line) && (hidden[index - 1] || hidden[index + 1]))
+      return [];
+    return hidden[index] ? [] : [line];
+  });
   try {
-    error.stack = visible.join("\n");
+    error.stack = withinStackLimit(visible).join("\n");
   } catch (e) {
   }
   return error;
@@ -931,7 +992,7 @@ function withNodeAssertionPhase(operation, source, callback) {
   // with the frames its author would see.
   if (!scope) {
     try {
-      return callback();
+      return withStackRoom(callback);
     } catch (error) {
       throw cleanInstrumentationStack(error, lexical);
     }
@@ -968,7 +1029,7 @@ function withNodeAssertionPhase(operation, source, callback) {
   attempt.phases.push(phase);
   attempt.phaseIds.add(phase.id);
   try {
-    const result = withCoverageCarrier({ version: 1, scope, phaseId: phase.id }, callback);
+    const result = withStackRoom(() => withCoverageCarrier({ version: 1, scope, phaseId: phase.id }, callback));
     if (result && typeof result.then === "function")
       return Promise.resolve(result).then((value) => {
         finishAssertionPhase(phase);
@@ -1886,6 +1947,7 @@ const directRuntimeApi = {
   coverageContextEnvironment,
   coverageContextHeaders,
   cleanInstrumentationStack,
+  withStackRoom,
   coverageHit,
   coverageHitV2,
   coverageSnapshot,
@@ -1950,6 +2012,7 @@ export {
   coverageContextEnvironment,
   coverageContextHeaders,
   cleanInstrumentationStack,
+  withStackRoom,
   coverageHit,
   coverageHitV2,
   coverageSnapshot,

package/runtime/javascript/tap.mjs

@@ -19,9 +19,10 @@ import { runnerExecutionScope, writeRunnerEvidence } from "./runnerEvidence.mjs"
 async function subtestClasses() {
     const classes = [];
     let fromTap;
+    let tap;
     try {
         const fromProject = createRequire(join(process.cwd(), "package.json"));
-        const tap = realpathSync(dirname(fromProject.resolve("tap/package.json")));
+        tap = realpathSync(dirname(fromProject.resolve("tap/package.json")));
         fromTap = createRequire(join(tap, "package.json"));
     }
     catch {
@@ -54,6 +55,22 @@ async function subtestClasses() {
     // libtap is CommonJS, and its exports hide lib/: reach it from its main.
     try {
         const lib = dirname(fromTap.resolve("libtap"));
+        // tap sets libtap up before it loads it: which frames are tap's own,
+        // and how a frame is taken through a source map. Loaded from here
+        // first, libtap kept its defaults for the whole file, and a failure
+        // listed tap's frames under the test's.
+        try {
+            fromTap(join(tap, "settings.js"));
+        }
+        catch {
+            // A tap that has no settings of its own leaves libtap's.
+        }
+        try {
+            nameFromTheCopy(createRequire(join(lib, "test.js"))("stack-utils"));
+        }
+        catch {
+            // Frames stay as libtap writes them.
+        }
         classes.push(createRequire(import.meta.url)(join(lib, "test.js")));
     }
     catch {
@@ -62,6 +79,49 @@ async function subtestClasses() {
     return classes;
 }
 
+// libtap takes the directory the test runs in off a frame, which under
+// Supercov is the copy, while a measured file's frame names the file its
+// author wrote: the whole of `/home/me/shop/src/crypto.js` for
+// `src/crypto.js`. A frame in the project is placed in the copy before
+// libtap reads it, as Mocha's are.
+function nameFromTheCopy(StackUtils) {
+    const real = (directory) => {
+        try {
+            return directory ? realpathSync(directory).replace(/\\/g, "/") : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const project = real(process.env.SUPERCOV_SOURCE_PROJECT_ROOT);
+    const copy = real(process.env.SUPERCOV_PROJECT_ROOT);
+    const { clean, at, parseLine } = StackUtils?.prototype ?? {};
+    if (!project || !copy || project === copy || typeof clean !== "function" || clean.supercovTap)
+        return;
+    const inTheProject = (text) => text.includes(`${project}/`) && !text.includes(`${copy}/`);
+    StackUtils.prototype.clean = function supercovTapClean(stack, ...rest) {
+        const lines = (Array.isArray(stack) ? stack : String(stack).split("\n")).map((line) => {
+            const text = String(line).replace(/\\/g, "/");
+            return inTheProject(text) ? text.split(`${project}/`).join(`${copy}/`) : line;
+        });
+        return Reflect.apply(clean, this, [lines, ...rest]);
+    };
+    StackUtils.prototype.clean.supercovTap = true;
+    const placed = (found) => {
+        if (typeof found?.file === "string" && found.file.startsWith(`${project}/`) && !found.file.startsWith(`${copy}/`))
+            found.file = found.file.slice(project.length + 1);
+        return found;
+    };
+    if (typeof at === "function")
+        StackUtils.prototype.at = function supercovTapAt(...given) {
+            return placed(Reflect.apply(at, this, given));
+        };
+    if (typeof parseLine === "function")
+        StackUtils.prototype.parseLine = function supercovTapParseLine(...given) {
+            return placed(Reflect.apply(parseLine, this, given));
+        };
+}
+
 export async function adaptTap(testFile) {
     const evidenceDirectory = process.env.SUPERCOV_EVIDENCE_DIR;
     if (!evidenceDirectory)