supercov 2.0.1 → 3.0.1

package/docs/coverage-model.md

@@ -150,9 +150,8 @@ or generated output merely to make a warning disappear.
 
 ## Assertion percentage
 
-When a run has an `assertions.json` map, its regular summary also shows
-agent-assessed assertion coverage: credited measured statements divided by all
-measured statements. This row always describes the whole archived run,
-independently of `--filter`, `--kind` and `--runner`. It is separate from the
-structural metrics above. See [assertion maps](assertion-maps.md) for credit,
-freshness and incomplete-map rules.
+When a run has been assessed with `assertions assess`, its regular summary also
+shows assertion coverage: executed statements a test is judged to catch
+breaking, divided by all assessed statements. This row always describes the
+whole run, independently of `--filter`, `--kind` and `--runner`, and is separate
+from the structural metrics above. See [assertion coverage](assertions.md).

package/docs/evidence.md

@@ -134,14 +134,3 @@ SUPERCOV_TEST_KIND=integration npx supercov -- npm test
 
 Supported values are `unit`, `component`, `integration` and `e2e`. Use separate
 runs when different suites need different classifications.
-
-## When assertion evidence is missing
-
-A test can make assertions without executing measured application code. It
-might check static data or a dependency, or use work performed in shared setup.
-Missing attribution across an asynchronous boundary can also leave a gap.
-
-The assertion detail explains why a mapped node did or did not receive credit.
-Use [Investigating assertion evidence](assertion-evidence.md) to distinguish
-these cases. The report's runtime action-phase counts are separate from the
-assertion map; zero action-phase lines does not mean zero asserted statements.

package/docs/getting-started.md

@@ -139,7 +139,7 @@ if anything is missing.
 - for Go, Go 1.22 or newer;
 - for Java and Kotlin, JDK 17 or newer, with Maven or Gradle;
 - for Python, CPython 3.9 or newer with pytest or unittest;
-- for Ruby, Ruby 3.4 or newer with RSpec, Minitest, test-unit or Cucumber (3.3 measures lines, methods and simple branches only).
+- for Ruby, Ruby 3.3 or newer with RSpec, Minitest, test-unit or Cucumber.
 
 The CLI is a native binary. `npx supercov` picks the build for your operating
 system and architecture, and nothing is compiled on install; the same binary is

package/docs/performance.md

@@ -130,18 +130,10 @@ Use `--dry-run` to preview cleanup. Keep enough run history for active reviews
 and automation; remove the cache only when reclaiming space matters more than a
 faster next run.
 
-## Keep assertion investigation fast
+## Keep assertion assessments fast and cheap
 
-Save `assertions.json` and query the run to see the updated score. Supercov does
-not rerun tests or call a model to calculate the report. Repeated queries reuse
-the previous assessment while checking that your source still matches the run.
-Editing the map automatically refreshes that assessment.
-
-For large maps, ask for a short page instead of the whole graph. Within one
-flow, `--view nodes` or `--view edges` pages the details; `--compact` omits repeated
-source text while keeping locations and credit reasons. See
-[Investigating assertion evidence](assertion-evidence.md#read-a-large-flow).
-
-The disposable `assertions.report.cache.json` and `assertions.summary.cache.json`
-files live beside the map. A missing or damaged cache is rebuilt. Removing it affects the next query's speed, not
-your saved explanations.
+`assertions assess` asks only questions it has not answered before; answers live
+in `.supercov/assertions/` and are reused across runs whenever the question is
+the same. `--workers N` raises the requests in flight (default 8) for a faster,
+slightly costlier pass. `--dry-run` prints the estimate without sending
+anything.

package/docs/quality.md

@@ -1,6 +1,6 @@
 # Understanding quality
 
-`supercov quality` tells you what is in your code: twelve named properties,
+`npx supercov quality` tells you what is in your code: twelve named properties,
 checked file by file, so a score is never a number you have to take on faith.
 
 Judgments come from [Jev](https://typesafe.ai), which answers typed questions

package/docs/security.md

@@ -1,10 +1,10 @@
 # Security surface
 
-`supercov security` tells you what security-relevant surface each file shows:
+`npx supercov security` tells you what security-relevant surface each file shows:
 twelve named checks, asked file by file, each mapped to the weakness classes it
 stands for. There is no score. A file is clean, or it names what fired.
 
-Judgments come from [Jev](https://typesafe.ai), the same way `supercov quality`
+Judgments come from [Jev](https://typesafe.ai), the same way `npx supercov quality`
 gets them. Set `TYPESAFE_API_KEY`, and optionally another provider, as described
 in [quality](quality.md); reading a saved assessment never needs a key.
 
@@ -50,16 +50,47 @@ attempt measured on the labelled corpus fired on unguarded handlers the
 application leaves open by design as often as on the ones it should not.
 
 
-Measured with this command on fifteen held-out repositories of a
-140-repository labelled corpus, whole repositories, at finding level: F1
-0.47 with 54% precision and 41% recall, where Semgrep scores 0.14, the
-general agentic LLM scanners 0.50 to 0.60, and the two leaders 0.76 and
-0.77, at about two cents per repository against 30 cents to 4 dollars for
-the agentic scanners. Injection, secrets, path, redirect and mass
-assignment are found at 70 to 90% recall; authorisation and authentication
-at 10%, because the guard that decides them lives in another file. A file
-too large for one request is read in windows at declaration boundaries.
-
+Measured with 2.0.1 on the 72 held-out repositories of RealVuln, a
+140-repository labelled corpus, scored by its own rule: F1 0.42 with 42%
+precision and 43% recall, in a median of 10 seconds and about 5 cents a
+repository. The strongest agent-based scanners score 0.69 to 0.71 but take
+5 to 9 minutes and about $4 a repository; Semgrep's default rules score 0.11.
+Redirects, injection, unsafe code execution and paths taken from a request
+are found at 79 to 89% recall; authorisation (11%) and authentication (24%)
+are the weakest, because the guard that decides them lives in another file.
+Every scanner's results are at
+[supercov.com/docs/security-benchmark](https://supercov.com/docs/security-benchmark).
+A file too large for one request is read in windows at declaration
+boundaries, or at line boundaries where Supercov has no parser for it, such as
+a template.
+
+## What is read
+
+Security reads every source file, template and configuration file that the
+conventions do not exclude, including files under no recognised source root,
+because code a project did not declare is deployed as often as not.
+`npx supercov security scope` lists exactly the files a run reads and why the
+rest were left out. Three kinds are left out because they are not the code
+under review:
+
+- **Tests and generated output**, as for `quality`.
+- **Vendored and minified JavaScript.** A minified file anywhere, and in a
+  served or vendor directory (`static/`, `public/`, `assets/`, `plugins/`,
+  `vendor/`, `lib/`) a file with a licence banner or a well-known library's
+  name, such as `jquery.flot.js` or `swagger-ui-bundle.js`.
+- **JSON data.** A JSON file is read when its name or directory says it
+  configures something (`config.json`, `proxy.conf.json`, `appsettings.json`,
+  `secrets.json`, anything under `config/`), and not when it holds data such
+  as translations, schema snapshots or scanner output.
+
+A directory called `target/` is build output only when a build that writes
+there (Cargo, Maven, Gradle, sbt, Leiningen) is declared beside it; otherwise
+it is read like any other. Name a file directly to read it whatever the scope
+says: `npx supercov security static/js/app.min.js`.
+
+A run that could not assess a few files still exits 0: each one is in the
+report with its reason, and stderr says how many. It exits 2 only when no
+file could be assessed.
 ## Across files
 
 The second pass also labels every function of every file, on the same

package/docs/supported-suites.md

@@ -50,9 +50,11 @@ Supercov reports the level it actually observed. It does not guess.
 | --- | --- |
 | Playwright | Exact per test, worker, retry, outcome, action, and assertion phase |
 | Vitest | Exact per test, with setup execution kept separate; Browser Mode included |
-| Jest | Exact per test, including parameterized tests, with the user's own configuration, setup files and reporters kept; passing `expect` occurrences are identified for assertion maps |
+| Jest | Exact per test, including parameterized tests, with the user's own configuration, setup files and reporters kept |
 | `node:test` | Exact per test |
-| AVA and Mocha | Aggregate structural coverage |
+| Mocha | Exact per test and retry, `--parallel` included, with setup execution kept separate |
+| AVA | Exact per test, concurrent tests included, in worker threads or child processes |
+| node-tap 15 and newer | Exact per subtest, nested and parallel (`t.jobs`) subtests included |
 | Other Node-based runners | Aggregate when their processes remain visible to Supercov |
 | Browser component runners without an adapter | Aggregate structural coverage |
 
@@ -81,9 +83,6 @@ obligations. `{value}` is reached exactly when the tree is, and
 `onClick={() => save()}` is measured where the handler is called rather than
 where it is created.
 
-`expect.element(...)`, `expect.soft(...)` and `expect.poll(...)` are recognised
-as assertions, so their passing occurrences are available to assertion maps.
-
 ### React and React Native
 
 React components can use Testing Library with Vitest/jsdom, Vitest Browser Mode,
@@ -93,11 +92,10 @@ it does not measure Hermes, native modules, simulator/device execution, Detox or
 Maestro. React SSR hydration is exercised in jsdom and Chromium; this does not
 establish Next.js Server Components, streaming SSR or server actions.
 
-An assertion map can explain which displayed value, accessible name, disabled
-state or error message a test checks. JSX expression coverage and a passing
-assertion are evidence for reviewing that explanation, not automatic semantic
-proof. A button being rendered does not establish that its disabled state was
-checked. Keep your existing runner and matchers.
+Assertion coverage treats a JSX expression as a statement: it asks whether a
+test would notice the displayed value, accessible name, disabled state or error
+message becoming undefined. A button being rendered does not establish that its
+disabled state was checked. Keep your existing runner and matchers.
 
 The [React verification example](https://github.com/supercorp-ai/supercov/tree/main/examples/react-verification)
 shows a fully executed checkout whose weak tests accept four UI regressions,
@@ -118,11 +116,6 @@ Supercov runs the project's build inside the isolated copy before testing.
 Keep using your normal test and build commands. Instrumentation does not
 require changing the project's TypeScript settings.
 
-For assertion maps, Node, Vitest, Jest and Playwright's Node-side assertions
-supply supported passing-occurrence evidence. Custom assertion wrappers and
-browser-side checks can have additional observation limits. See
-[Assertion evidence](assertion-evidence.md) before interpreting a missing occurrence.
-
 ### Browsers, servers, and child processes
 
 Playwright support includes Chromium, Firefox, and WebKit, along with pages,
@@ -169,6 +162,19 @@ modules. Statements, functions, branches, boolean decisions, loops and error
 propagation are measured. Const contexts and macro expansions remain visible
 with explicit measurement limitations.
 
+Test code is not measured, as cargo-llvm-cov and cargo-tarpaulin leave it out:
+files under a `tests`, `examples` or `benches` directory, files named
+`tests.rs`, `*_tests.rs` or `*-tests.rs`, everything a test target or a
+`#[cfg(test)]` module declares, and items marked `#[cfg(test)]`, `#[test]` or
+`#[bench]`. Its assertions still mark which evidence a passing assertion
+witnessed.
+
+Neither is code the compiler never builds for the target: a `#[cfg(windows)]`
+function on Linux, or one behind `#[cfg(not(target_os = "macos"))]` on a Mac,
+is not counted. Only predicates the target settles (`unix`, `windows`,
+`target_*`) are decided; an item behind a feature or a custom cfg is counted
+either way.
+
 Use the repository's normal flags after the wrapped command:
 
 ```sh
@@ -200,7 +206,8 @@ comprehensions, short-circuit operators, `match` cases and exception paths.
 Child interpreters, threads and thread pools can retain the calling test's
 identity. The report also distinguishes execution before a passing assertion
 from later execution. These phase records alone do not prove which values the
-assertion checks.
+assertion checks; [assertion coverage](assertions.md) measures which executed
+statements the pytest and unittest tests would catch breaking.
 
 Interpreters launched with `-I`, `-E` or `-S` ignore the required startup hook
 and are not measured. Code compiled from strings at runtime has no source
@@ -222,23 +229,21 @@ npx supercov -- python -m unittest
 | Runner | Attribution | Current requirement |
 | --- | --- | --- |
 | RSpec | Exact example and before/example/after phase identity | Ruby 3.4 or newer for full measurement; run with `npx supercov -- rspec` or `bundle exec rspec` |
-| Minitest (including Minitest::Spec and ActiveSupport::TestCase) | Exact test and setup/test/teardown identity; a test's coverage is a lower bound (see below); skips recorded | `ruby -Itest ...`, `rake test`, `rails test` |
+| Minitest (including Minitest::Spec and ActiveSupport::TestCase) | Exact test and setup/test/teardown identity; skips recorded | `ruby -Itest ...`, `rake test`, `rails test` |
 | test-unit | Exact test and setup/test/teardown identity; omissions and pendings recorded | `ruby -Itest ...`, `rake test` |
 | parallel_tests, Rails process workers | Exact per worker process | Workers inherit the run through `RUBYOPT`; verified on a Rails app with bootsnap, Zeitwerk and two forked workers |
 | Thread-parallel Minitest (`parallelize_me!`, `parallelize(with: :threads)`) | Probe observations exact per test; line, method and simple-branch observations made while phases overlapped go to the run, declared | |
 | Cucumber | Exact scenario identity (`features/x.feature:LINE`), hook steps as setup/teardown | `cucumber`, `bundle exec cucumber` |
 
-Ruby reports a line the first time it executes and never again, which is what
-makes collecting coverage cheap enough to leave on. So a test is credited with
-the lines it was first to reach, and a later test running the same lines is
-credited with none of them: what a test is credited with is really its own, and
-what it is not credited with is not evidence it did not run the code.
-
-Totals are unaffected — every line is credited to exactly one test. What this
-changes is per-test reporting: `supercov runs <id> test <name>` gives its
-numbers as "at least", and `tests affected` reports a test whose own record
-cannot settle the question as **undetermined** rather than unaffected, so
-`--names` includes it in the set to run.
+Every test is credited with every line it runs: each statement of an
+instrumented file carries a probe. Code Supercov cannot instrument -- a file
+it could not compile with its probes, or a `Ractor.new` block, where no probe
+can run -- falls back to Ruby's one-shot line coverage, which reports a line
+the first time it executes and never again. There a test is credited with the
+lines it was first to reach; what it is not credited with is not evidence it
+did not run the code. The run says so, per-test numbers there read "at least",
+and `tests affected` reports a test whose own record cannot settle the
+question as **undetermined**, so `--names` includes it in the set to run.
 
 Your project runs in place with its own interpreter and bundle. Supercov loads
 through `RUBYOPT`; application files on disk and their backtrace line numbers
@@ -246,11 +251,9 @@ stay unchanged. RSpec, Minitest and test-unit assertions can identify execution
 before a passing assertion. That timing evidence alone does not show which
 values the assertion checks.
 
-Ruby 3.4 and newer support statement, method, branch and MC/DC measurement,
+Ruby 3.3 and newer support statement, method, branch and MC/DC measurement,
 including loops, iterator blocks, short-circuit operators, pattern matching,
-optional calls and exception paths. Ruby 3.3 supplies Ruby's own line, method
-and branch coverage; obligations requiring additional instrumentation are
-reported as measurement limits.
+optional calls and exception paths.
 
 Some constructs have narrower coverage. Code in a non-main Ractor keeps line
 coverage but may lack other observations. Certain nested-return expressions
@@ -300,7 +303,7 @@ which costs whatever its parallelism was worth — on sixteen I/O-bound JUnit
 tests across fifteen cores, 3.6x. Either way the coverage totals are the same;
 what changes is whether a line can be traced to the test that ran it.
 
-`supercov runs latest` reports which you got, under `Attribution`.
+`npx supercov runs latest` reports which you got, under `Attribution`.
 
 ## Go
 
@@ -332,7 +335,7 @@ measured the same way: `go test` runs both, and what they reach is real
 coverage no test can claim.
 
 Such a test is still recorded as having run, with its outcome, and credited
-with no coverage. `supercov runs <id> test <name>` says that rather than
+with no coverage. `npx supercov runs <id> test <name>` says that rather than
 reporting zeroes, coverage percentages leave it out, and `tests affected` lists
 it as **undetermined**: nothing can say a change missed it, so `--names`
 includes it in the set to run. A package where every test calls `t.Parallel()`
@@ -347,10 +350,6 @@ no way to run code on `os.Exit`, and a `TestMain` need not reach the `m.Run()`
 call Supercov wraps — `goleak.VerifyTestMain(m)` runs the suite and exits
 itself. Without periodic writes such a run recorded nothing at all.
 
-For assertion maps, `t.Error`, `t.Errorf`, `t.Fatal`, `t.Fatalf` and testify's
-`assert` and `require` are inventoried. A Go test states its claim with an `if`
-and reports the violation, so the report is the site.
-
 A repository with several modules works either way it is laid out. A directory
 with a `go.mod` of its own that no `go.work` names is a different module, and
 `go test ./...` walks past it, so Supercov leaves it alone. A `go.work`
@@ -372,7 +371,7 @@ npx supercov -- go test ./core/... ./app/...
 | Kotest | Exact per test, under the names Kotest itself reports | — |
 | Spock | Exact per feature, under the names Spock itself reports | — |
 | TestNG | Exact per test, each data-provider invocation its own | — |
-| JUnit 4 alone | Exact per test, through Vintage — see below | Maven |
+| JUnit 4 alone | Exact per test, through Vintage — see below | Maven or Gradle |
 
 Multi-module builds are measured module by module: each compiles its own source
 set and forks its own JVM, so each gets a runtime and records evidence of its
@@ -391,10 +390,11 @@ report name the same thing.
 JUnit 4 on its own is not a platform engine and does not run on one. Maven and
 Gradle choose a test provider from what is on the classpath, so putting the
 platform there makes the build pick a provider that finds no engine and fail.
-For a Maven module, Supercov adds `junit-vintage-engine` to the copy — the
-platform's own way of running exactly those JUnit 4 tests through the lifecycle
-it listens to — and measures them; your own build still runs JUnit 4 as it did.
-A Gradle module is left alone and told about rather than broken.
+Supercov adds `junit-vintage-engine` to the copy — the platform's own way of
+running exactly those JUnit 4 tests through the lifecycle it listens to — and
+measures them; your own build still runs JUnit 4 as it did. In a Gradle build
+the copy also switches each JUnit 4 module's test tasks to `useJUnitPlatform()`,
+leaving any task the build already put on the platform or on TestNG as it was.
 
 Supercov instruments an isolated copy and leaves your build file alone. In the
 copy it adds a test-scoped `junit-platform-launcher`, because the listener is
@@ -423,15 +423,11 @@ same goes for a loop over a constant, `while (true)`, which can only go one
 way. A Kotlin `contract { }` has to stay the first statement of its function,
 so the probe that records the function being entered is written after it.
 
-Every one of these is named in the run: ask for `supercov runs latest
+Every one of these is named in the run: ask for `npx supercov runs latest
 limitations` and each appears with its file, its line, and why it was left
 alone. A source file the parser cannot read is declared there too, so a hole in
 the denominator stays visible after the build log is gone.
 
-For assertion maps, forms spelled `assertSomething`, `assertThat` or `fail` are
-inventoried, which covers JUnit, TestNG, AssertJ, Hamcrest and kotlin.test.
-Kotest's infix matchers are not.
-
 ```sh
 npx supercov -- mvn test
 npx supercov -- ./gradlew test

package/docs/troubleshooting.md

@@ -93,11 +93,18 @@ outside that loader. Supercov declares this boundary on the affected file,
 including on Python 3.9–3.11. It does not silently rewrite the child command,
 which could change imports, `sys.argv`, or process behavior.
 
-A file can therefore have tests that touched it through an import, while a
-separate direct execution makes its overall coverage unmeasured. Those lines
-are excluded from both the measured denominator and the uncovered-lines list.
-Inspect the file's measurement limitations before treating a zero denominator
-as complete coverage.
+A file that tests also import stays measured: what the imports ran is
+counted, and the file carries the limitation, because lines it shows as
+uncovered may have run in the direct execution. Its numbers are a lower bound,
+and the run reports its measurement as incomplete. A file that is only ever
+run directly has nothing observed, and is left out of the measured denominator
+and the uncovered-lines list; inspect its measurement limitations before
+treating a zero denominator as complete coverage.
+
+To have a script measured, run it through the import system:
+`python -m package.module`, or, for a file whose name is not a module name
+such as `bin/anti-drift-gate.py`, `runpy.run_path("bin/anti-drift-gate.py",
+run_name="__main__")` from a test.
 
 ## Python subprocess output or timeout assertions fail
 

package/docs/workspace-isolation.md

@@ -27,6 +27,19 @@ snapshots, calls a service, or changes a database, wrapping it does not remove
 that behavior. The isolation guarantee applies to Supercov's instrumentation
 and evidence work.
 
+## Tools that judge the code
+
+Some tools a test command runs read or measure the code instead of running it,
+and the instrumented copy is not what you wrote:
+
+- Linters, formatters and `tsc --noEmit` (ESLint, Prettier, standard, xo and
+  the like) read each file as you wrote it, and don't see `.supercov`.
+- Coverage tools the command runs itself (tap, c8, nyc, Jest's and Vitest's
+  `--coverage`) still collect and report coverage. They measure the
+  instrumented copy, and report close to what they report without Supercov,
+  but not always exactly, so their thresholds are not checked, and the run
+  prints a line saying so. Supercov's own report has the run's coverage.
+
 Files the wrapped command creates or changes inside the isolated workspace are
 synced back to the project after the run, so `supercov -- npm test -- -u`
 updates snapshots in the repository exactly as `npm test -- -u` would. Two
@@ -87,8 +100,16 @@ project lock, and does not scan for similarly named directories.
 ## Containers and remote workspaces
 
 When a suite launches a container or VM from a mounted workspace, Supercov uses
-the isolated workspace as the source presented to that environment. The runtime
-must be able to cross the launch boundary and return evidence.
+the isolated workspace as the source presented to that environment. Where it
+sees the launch call -- a command and its environment passed as an `env`,
+`environment` or `envs` option, as a plain map after the command, or to a
+builder method such as Testcontainers' `withEnvironment` -- it hands the guest
+its settings with paths moved to the guest's mount, and the guest's coverage is
+credited to the test that launched it. A guest started any other way, with none
+of those settings, still runs the instrumented code: it reads the run's
+settings from the mounted workspace itself, and its coverage counts for the run
+as background coverage, credited to no test. The run summary's `Guests` line
+says how many processes did that.
 
 Dependencies stay out of the instrumented copy. The root `node_modules` is
 linked entry by entry to the project's own, so an environment that mounts the

package/package.json

@@ -1,7 +1,24 @@
 {
   "name": "supercov",
-  "version": "2.0.1",
+  "version": "3.0.1",
   "description": "Coverage, security and code quality for coding agents",
+  "keywords": [
+    "coverage",
+    "code-coverage",
+    "test-coverage",
+    "branch-coverage",
+    "mcdc",
+    "vitest",
+    "jest",
+    "playwright",
+    "pytest",
+    "security",
+    "code-quality",
+    "coding-agents",
+    "claude-code",
+    "codex",
+    "cli"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -20,9 +37,6 @@
     "docs/assertions.md",
     "docs/quality.md",
     "docs/security.md",
-    "docs/assertion-evidence.md",
-    "docs/assertion-maps.md",
-    "docs/assertion-agent.md",
     "docs/troubleshooting.md",
     "docs/cli.md",
     "docs/coverage-model.md",
@@ -31,7 +45,6 @@
     "docs/verification.md",
     "docs/performance.md",
     "docs/workspace-isolation.md",
-    "schemas",
     "README.md"
   ],
   "engines": {
@@ -52,9 +65,6 @@
     "build": "cargo build -p supercov",
     "sync:rust-assets": "node scripts/sync-rust-package-assets.mjs",
     "test:rust-assets": "node scripts/sync-rust-package-assets.mjs --check",
-    "check:rustc-backend-spike": "(cd spikes/rustc-backend && RUSTC_BOOTSTRAP=1 RUSTUP_TOOLCHAIN=1.95.0 cargo fmt --check && RUSTC_BOOTSTRAP=1 RUSTUP_TOOLCHAIN=1.95.0 cargo clippy --all-targets -- -D warnings)",
-    "test:rustc-backend-spike": "node scripts/rustc-backend-spike.mjs",
-    "test:rust-compiler-spikes": "cargo build -p supercov && node scripts/rust-libtest-companion-spike.mjs && node scripts/rust-async-attribution-spike.mjs && node scripts/rust-subprocess-attribution-spike.mjs && node scripts/rust-custom-harness-spike.mjs && node scripts/rust-libtest-builder-lifecycle-spike.mjs",
     "test": "cargo test --workspace",
     "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",
@@ -71,7 +81,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-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/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",
@@ -84,7 +94,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:assertion-maps && 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: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",
@@ -98,9 +108,7 @@
     "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:assertion-maps": "cargo build -p supercov && node scripts/assertion-map-schema.mjs --check && node scripts/assertion-map-integration.mjs && node scripts/assertion-map-js-integration.mjs && node scripts/assertion-dogfood-integration.mjs",
-    "test:assertion-maps:js": "cargo build -p supercov && node scripts/assertion-map-schema.mjs --check && node scripts/assertion-map-js-integration.mjs && node scripts/assertion-dogfood-integration.mjs",
-    "sync:assertion-schema": "cargo build -p supercov && node scripts/assertion-map-schema.mjs",
+    "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",
     "test:launcher": "go vet ./cmd/... && go test ./cmd/...",
@@ -110,14 +118,14 @@
     "test:windows-tls": "node scripts/windows-tls-test.mjs"
   },
   "optionalDependencies": {
-    "@supercov/cli-darwin-arm64": "2.0.1",
-    "@supercov/cli-darwin-x64": "2.0.1",
-    "@supercov/cli-linux-arm64-gnu": "2.0.1",
-    "@supercov/cli-linux-arm64-musl": "2.0.1",
-    "@supercov/cli-linux-x64-gnu": "2.0.1",
-    "@supercov/cli-linux-x64-musl": "2.0.1",
-    "@supercov/cli-win32-arm64": "2.0.1",
-    "@supercov/cli-win32-x64": "2.0.1"
+    "@supercov/cli-darwin-arm64": "3.0.1",
+    "@supercov/cli-darwin-x64": "3.0.1",
+    "@supercov/cli-linux-arm64-gnu": "3.0.1",
+    "@supercov/cli-linux-arm64-musl": "3.0.1",
+    "@supercov/cli-linux-x64-gnu": "3.0.1",
+    "@supercov/cli-linux-x64-musl": "3.0.1",
+    "@supercov/cli-win32-arm64": "3.0.1",
+    "@supercov/cli-win32-x64": "3.0.1"
   },
   "peerDependencies": {
     "@playwright/test": ">=1.55.0",
@@ -140,9 +148,13 @@
     "@swc/core": "^1.16.1",
     "@types/node": "^24.0.0",
     "@vitest/browser-playwright": "4.1.11",
+    "@vitest/coverage-v8": "4.1.11",
+    "ava": "8.0.1",
     "esbuild": "^0.28.2",
     "expect": "30.4.1",
     "jest": "30.5.1",
+    "libtap": "1.4.1",
+    "mocha": "12.0.3",
     "next": "^16.3.2",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",

package/runtime/javascript/atomic.mjs

@@ -1,6 +1,7 @@
-import { appendFileSync, existsSync, mkdirSync, openSync, closeSync, fsyncSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, openSync, closeSync, fsyncSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { randomUUID } from "node:crypto";
-import { dirname } from "node:path";
+import { dirname, resolve } from "node:path";
+import { Buffer } from "node:buffer";
 function fsyncDirectory(path) {
     try {
         const directory = openSync(path, "r");
@@ -64,3 +65,46 @@ export function atomicRenameSync(source, destination) {
     renameSync(source, destination);
     fsyncDirectory(dirname(destination));
 }
+/**
+ * Append one test's evidence to this writer's own journal.
+ *
+ * A file per test cost a directory, a temporary file, two fsyncs and a rename:
+ * jshttp/cookie's 63,740 tests had written 26,600 of them after seven
+ * minutes, where the suite alone takes two seconds. An append is one write the
+ * kernel keeps when the process is killed, which is the durability the rest of
+ * the workspace has; set SUPERCOV_DURABLE_EVIDENCE_EACH_TEST=1 to fsync each
+ * record as well. The reader already takes `*.mcdc.jsonl` journals, one record
+ * per line, as Playwright writes them.
+ *
+ * A journal is named by a token, never by the pid alone: worker threads share
+ * a pid, and VMs restored from one snapshot share the token too, so a journal
+ * that grew by anything but this writer's own appends is left to its other
+ * writer and a new one is started.
+ */
+const journals = new Map();
+export function appendEvidenceRecord(directory, prefix, payload) {
+    const line = `${JSON.stringify(payload)}\n`;
+    let journal = journals.get(prefix);
+    if (journal) {
+        let size = -1;
+        try {
+            size = statSync(journal.path).size;
+        }
+        catch {
+            // A missing journal is started again below.
+        }
+        if (size !== journal.size)
+            journal = undefined;
+    }
+    if (!journal) {
+        const writer = (process.env.SUPERCOV_EXECUTION_LOG_SHARD ?? `pid-${process.pid}`)
+            .replace(/[^A-Za-z0-9_-]/g, "_");
+        journal = { path: resolve(directory, `${prefix}-${writer}-${randomUUID()}.mcdc.jsonl`), size: 0 };
+        journals.set(prefix, journal);
+    }
+    const append = process.env.SUPERCOV_DURABLE_EVIDENCE_EACH_TEST === "1"
+        ? appendJsonLineDurableSync
+        : appendJsonLineSync;
+    append(journal.path, line);
+    journal.size += Buffer.byteLength(line);
+}