supercov 4.3.0 → 4.5.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
 
@@ -344,6 +344,29 @@ npx supercov report
 
 Collections accept `--limit` and `--offset` and print a copyable next-page command. Machine-readable output is available with `--json` when an integration needs it.
 
+## Comment on pull requests
+
+In GitHub Actions, one step runs your tests and tells the pull request which
+changed lines no test ran:
+
+```yaml
+permissions:
+  contents: read
+  pull-requests: write
+
+steps:
+  - uses: actions/checkout@v6
+  - run: npm ci
+  - uses: supercorp-ai/supercov@v4
+    with:
+      command: npm test
+```
+
+It works with every supported language, keeps one comment up to date, marks the
+lines in the diff, and can fail the job below a floor (`min-changed-lines: 90`).
+No account, no upload token and no server: the report never leaves the runner.
+See [Comment on a pull request](docs/cli.md#comment-on-a-pull-request).
+
 ## Local, private, and zero-edit
 
 Everything Supercov writes lives under one hidden `.supercov/` directory: run evidence in `.supercov/runs/<run-id>/` and the isolated build cache in `.supercov/workspaces/`. It ignores itself in Git, so there is nothing to add to your `.gitignore`.

package/docs/assertions.md

@@ -83,9 +83,11 @@ 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`.
@@ -127,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
 
@@ -142,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` |
@@ -278,6 +279,62 @@ code nothing ran.
 adjacent misses into one range and capping the total (`--max-annotations`). It
 needs no token and posts no comment.
 
+## Comment on a pull request
+
+In GitHub Actions, one step runs the tests, says in a comment which changed
+lines no test ran, and marks them in the diff:
+
+```yaml
+on: pull_request
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - run: npm ci
+      - uses: supercorp-ai/supercov@v4
+        with:
+          command: npm test
+```
+
+`command` is the test command in any supported language: `pytest`,
+`cargo test`, `go test ./...`, `bundle exec rspec`, `mvn test`. The step takes
+the place of the one that ran the tests, and fails when they fail. It needs no
+account and no server: the comment is written with the workflow's own token,
+and everything else stays on the runner.
+
+The comment gives the coverage of the changed lines, the run's line, branch and
+MC/DC coverage, and each changed file with the lines no test ran, linked to the
+commit. A later push rewrites the same comment. The job summary holds the same
+report, which is what a pull request from a fork gets: its token cannot write a
+comment.
+
+| Input | Default | |
+| --- | --- | --- |
+| `command` | required | The test command. One command; put several in a script. |
+| `working-directory` | `.` | Where to run it. |
+| `min-changed-lines` | none | Fail below this percentage of changed lines covered. |
+| `min-lines`, `min-branches`, `min-mcdc` | none | Fail below this percentage for the whole run. |
+| `title` | `Coverage` | The comment's heading. Give each job its own when several comment on one pull request. |
+| `base` | the pull request's base | What the change is compared with. |
+| `comment`, `annotate` | `true` | Turn the comment or the marks in the diff off. |
+| `version` | the action's release | The Supercov release to run. |
+| `binary` | none | A `supercov` already on the runner, used instead of downloading one. |
+
+The default checkout fetches one commit; the step fetches the history between
+it and the base itself. It puts `supercov` on the `PATH` and sets the outputs
+`run-id`, `lines`, `branches` and `changed-lines`, so later steps can read the
+same run:
+
+```yaml
+      - run: supercov runs report --format html --output coverage/report
+```
+
 ## Export for other tools
 
 ```sh supercov-example
@@ -299,7 +356,13 @@ one to fill a field.
 
 MC/DC conditions are not exported as ordinary branches. A consumer would then
 show condition obligations as branch coverage, which is a different
-measurement; that evidence stays in the JSON view and the HTML report. A report
+measurement. The LCOV export writes them as LCOV 2's own records, `MCDC:` for
+each condition with `MCF:` and `MCH:` for a file, so `lcov --mcdc-coverage` and
+`genhtml --mcdc-coverage` show a per-file MC/DC figure from the export alone.
+LCOV counts a condition twice, once for each way it can turn the outcome, and
+Supercov's covered condition is both: hit over found is the run's MC/DC. A
+reader of the older format passes the records over. Cobertura has no such
+record; there the evidence stays in the JSON view and the HTML report. A report
 from a failed or stale run is still written, with a warning on stderr — only
 `check` refuses to pass on one.
 
@@ -367,6 +430,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
@@ -502,12 +578,37 @@ assessment, each commit cost under a cent.
 
 ```sh supercov
 npx supercov merge <shard-a> <shard-b> <shard-c>
+npx supercov merge
 ```
 
 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.
 
+With no run named, `merge` takes the runs recorded on the source as it is now:
+the newest of each command, leaving out runs that are themselves a merge. It
+prints the runs it took. This is what a script uses after measuring its
+suites, one after another or side by side, without knowing what each run was
+called. Asked again with nothing new, it names the merge already made.
+
+A test that is in two of the runs is one test in the merge. If it failed in
+either, it is failed, which is why a command run again replaces its earlier
+run and is not merged with it.
+
+The runs may differ in their tests when the later ones have only gained test
+files. Measuring a new test alone and adding it to the runs before it is
+then the whole suite's figure, without the whole suite's time:
+
+```sh supercov-example
+npx supercov -- npm test                       # the suite, once
+npx supercov -- npx vitest run test/new.test.ts   # a test added since, alone
+npx supercov merge
+```
+
+A run is left out, and named, when a file of its own tests has changed since
+it ran, or a file tests load that is not itself a test's: what it recorded is
+then of other tests. Measure those again to count them.
+
 `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

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/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/docs/workspace-isolation.md

@@ -114,12 +114,56 @@ partial output.
 
 ## Interrupted and overlapping commands
 
-One project can run one coverage or cleanup transaction at a time. A second
-operation fails clearly instead of racing the first.
+Runs of one project can be started at the same moment. Each takes a copy of
+the project to itself: a run alone always has the first,
+`.supercov/workspaces/workspace/<name>`, and one started while that is in use
+has `workspace-2`, the next `workspace-3`. None waits and none is refused:
+
+```sh
+npx supercov -- npm run test:unit &
+npx supercov -- npm run test:integration &
+npx supercov -- npm run test:e2e &
+wait
+npx supercov merge
+```
+
+`merge` with no run named adds up the runs recorded on the source as it is
+now, so a script does not have to know what each was called.
+
+A copy past the first is kept for a day after its last run, so that runs that
+overlap again start from what they left, and is removed after that. Rust runs
+build into one directory, as two `cargo test` do, and Cargo makes the second
+wait while the first compiles.
+
+Suites can also be started from one command. They are then one run with
+nothing to merge, and each test keeps the kind its own process was given:
+
+```sh
+npx supercov -- sh -c '
+  SUPERCOV_TEST_KIND=integration npm run test:integration & integration=$!
+  SUPERCOV_TEST_KIND=e2e npm run test:e2e & e2e=$!
+  wait $integration; first=$?
+  wait $e2e && exit $first
+'
+```
+
+`wait` with no argument ends with 0 whatever the suites did, which would turn a
+failing suite green; waiting for each by its id keeps the status.
+
+`runs clean` wants the store to itself. While a run is active it ends with
+status 2 and names the run; a run started while it works is told so, and no
+test of it runs.
 
 After interruption or host restart, the next command recovers unpublished
 staging state. Completed runs remain immutable.
 
+Ctrl-C ends the test command and the run: nothing is recorded, and the exit
+status is 130. A test command that reads the keyboard (a debugger at a
+breakpoint, a watch mode, a question before an install) is given the terminal
+when it first reads, on macOS and Linux. From then on Ctrl-C and Ctrl-Z go to
+it, as they do without Supercov, and a command that Ctrl-C ended is still a
+run that was interrupted.
+
 ## Clean up local data
 
 Preview cleanup before removing anything:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supercov",
-  "version": "4.3.0",
+  "version": "4.5.0",
   "description": "Coverage, security and code quality for coding agents",
   "keywords": [
     "coverage",
@@ -70,6 +70,7 @@
     "test:react": "cargo build -p supercov && node scripts/rust-vitest-projects-integration.mjs && npm --prefix examples/react-verification ci && npm --prefix examples/react-verification run demo && node scripts/react-hydration-compatibility.mjs",
     "test:release-tooling": "node --test tests/release/*.test.mjs",
     "test:runtime": "node --test tests/runtime/*.test.mjs",
+    "test:action": "cargo build -p supercov && node --test tests/action/*.test.mjs",
     "test:fixture": "cargo build -p supercov && node scripts/rust-fixture-matrix.mjs",
     "test:packed-npx": "cargo build --release -p supercov && node scripts/packed-npx-integration.mjs",
     "test:isolation": "cargo build -p supercov && node scripts/isolation-integration.mjs",
@@ -82,7 +83,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/side-by-side.mjs node && 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",
@@ -95,7 +96,7 @@
     "test:test262": "cargo build --release -p supercov && node scripts/test262-equivalence.mjs",
     "benchmark:check": "cargo build --release -p supercov && node scripts/rust-transform-benchmark.mjs",
     "benchmark:python": "cargo build -p supercov && node scripts/python-benchmark.mjs",
-    "check": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && npm run test && npm run test:release-tooling && npm run test:runtime && npm run test:rust-assets && npm run test:agent-commands && npm run test:assertions && npm run test:sweep-target && npm run test:skip-guard && npm run test:windows-tls && node scripts/package-preflight.mjs && node scripts/verify-binstall-metadata.mjs --offline",
+    "check": "cargo fmt --all -- --check && cargo clippy --workspace --all-targets -- -D warnings && npm run test && npm run test:release-tooling && npm run test:runtime && npm run test:action && npm run test:rust-assets && npm run test:agent-commands && npm run test:assertions && npm run test:sweep-target && npm run test:skip-guard && npm run test:windows-tls && node scripts/package-preflight.mjs && node scripts/verify-binstall-metadata.mjs --offline",
     "release:check": "cargo clean && node scripts/sweep-target.mjs && npm run check && npm run test:engine && npm run test:go && npm run test:jvm && npm run test:launcher && npm run test:fixture && npm run test:watchdog && npm run test:engine-contract && npm run test:agent && npm run test:child-attribution && npm run test:host-loader && npm run test:python && npm run test:ruby-coverage && npm run test:rust-public-cargo && npm run test:packed-npx && npm run test:clang-mcdc && npm run benchmark:check",
     "release:bump": "node scripts/bump-version.mjs",
     "sweep": "node scripts/sweep-target.mjs",
@@ -104,11 +105,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: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:python": "cargo build -p supercov && node scripts/python-integration.mjs && node scripts/failure-output.mjs python && node scripts/side-by-side.mjs python",
+    "test:ruby-coverage": "cargo build -p supercov && node scripts/ruby-coverage-integration.mjs && node scripts/failure-output.mjs ruby && node scripts/side-by-side.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 && node scripts/side-by-side.mjs go",
+    "test:jvm": "cargo test --no-fail-fast -p supercov-engine --test jvm_frontend --test jvm_run -- --include-ignored --test-threads=1 && cargo build -p supercov && node scripts/side-by-side.mjs jvm",
+    "test:rust-public-cargo": "cargo build -p supercov && node scripts/rust-public-cargo-integration.mjs && node scripts/failure-output.mjs rust && node scripts/side-by-side.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 +120,14 @@
     "test:windows-tls": "node scripts/windows-tls-test.mjs"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "4.3.0",
-    "@supercov/cli-darwin-x64": "4.3.0",
-    "@supercov/cli-linux-arm64-gnu": "4.3.0",
-    "@supercov/cli-linux-arm64-musl": "4.3.0",
-    "@supercov/cli-linux-x64-gnu": "4.3.0",
-    "@supercov/cli-linux-x64-musl": "4.3.0",
-    "@supercov/cli-win32-arm64": "4.3.0",
-    "@supercov/cli-win32-x64": "4.3.0"
+    "@supercov/cli-darwin-arm64": "4.5.0",
+    "@supercov/cli-darwin-x64": "4.5.0",
+    "@supercov/cli-linux-arm64-gnu": "4.5.0",
+    "@supercov/cli-linux-arm64-musl": "4.5.0",
+    "@supercov/cli-linux-x64-gnu": "4.5.0",
+    "@supercov/cli-linux-x64-musl": "4.5.0",
+    "@supercov/cli-win32-arm64": "4.5.0",
+    "@supercov/cli-win32-x64": "4.5.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.
@@ -272,9 +280,10 @@ process.__SUPERCOV_FAILURE_OUTPUT__ ??= function supercovFailureOutput(runner) {
             return [copy];
         }
     })();
-    // The copy lies in the project at .supercov/workspaces/workspace/<name>.
+    // The copy lies in the project at .supercov/workspaces/workspace/<name>,
+    // or at workspace-2 where it is one of several runs at once.
     const projects = copies
-        .filter((copy) => /[\\/]\.supercov[\\/]workspaces[\\/]workspace[\\/][^\\/]+[\\/]$/.test(copy))
+        .filter((copy) => /[\\/]\.supercov[\\/]workspaces[\\/]workspace(?:-\d+)?[\\/][^\\/]+[\\/]$/.test(copy))
         .map((copy) => resolve(copy, "../../../..") + sep);
     // The path inside the copy of a rewritten file that lies under one of `roots`.
     const rewrittenUnder = (roots, file) => {
@@ -288,9 +297,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 +448,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 +490,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 +553,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)