Crate supercov_engine 

Supercov’s single coverage engine. Target-language runtime adapters remain thin generated shims; instrumentation, orchestration, analysis and queries are owned here.

Modules

agent_json

assertion_coverage

Assertions coverage: which executed statements a test would catch breaking.

child_signal_guard

Take the test processes down with the runner.

coverage_analysis

Language-neutral coverage arithmetic and masking MC/DC witness search.

coverage_export

LCOV and Cobertura exports, written from the shared run view.

coverage_html

A static HTML report: one file, no network, no service.

coverage_index

Typed coverage columns stored in the immutable query-index container.

coverage_query

Language-neutral coverage query operators.

coverage_report

Language-neutral reconstruction of coverage views from frozen obligations and per-attempt evidence.

decision_shape

A decision’s boolean shape, read back from its source and its conditions: which vectors short-circuit evaluation can produce. The run that would show a condition deciding the result is one of them; one made by flipping a condition in a run that was seen often is not (a true in a || b cannot make the decision false).

docker_proxy

Containers a suite starts, through any Docker client.

evidence_archive

Language-neutral, streaming implementation of the frozen evidence archive.

frontend_detection

Language/frontend selection for the zero-configuration public command.

frontend_protocol

Validation boundary between language-specific producers and shared Rust analysis.

go_instrumenter

Supercov-owned Go parsing and obligation discovery.

go_project

Go project discovery: what Supercov measures, and what it deliberately does not.

go_run

Public, isolated Go coverage run lifecycle.

go_test_harness

Binding Go’s test functions to the evidence they produce.

indexed_query

One agent-query implementation over an authenticated immutable query index.

integrity

Language-neutral run integrity fingerprints.

interned

Ids a coverage report names over and over, stored once.

javascript_frontend

JavaScript source frontend for Rust-owned executions.

javascript_run

Rust-owned JavaScript execution for the public Supercov engine.

js_instrumenter

First oxc-backed vertical slice of the Rust JavaScript instrumenter.

jvm_instrumenter

Supercov-owned Java and Kotlin parsing and obligation discovery.

jvm_project

JVM project discovery for Maven and Gradle layouts.

jvm_run

Public, isolated JVM coverage run lifecycle, for Java and Kotlin.

lifecycle

Crash-safe run publication, recovery and explicit retention.

orchestration

Language-neutral execution plans over the Rust process supervisor.

outside_evidence

Line evidence measured where Supercov could not run, as an LCOV file, added to a run. Supercov runs no other coverage tool: a profile another tool recorded is exported as LCOV by that tool first.

owned_evidence

Turning what a Supercov-owned runtime wrote into the model the report reads.

owned_server

A server a browser suite drove, measured by a runtime Supercov owns: Go and the JVM. Their probes store into one array, which cannot tell two requests apart, so the runtime sweeps it on a clock into windows, and each window is credited, by time, to the one browser test whose span it overlaps. What no single test’s window holds is no test’s.

patch_view

Changed-line coverage: are the lines this change touches tested?

probe_v2

process_supervision

Privacy-preserving child-process supervision for arbitrary test commands.

progress

A single branded status line on stderr while a long, otherwise-silent step runs.

project_discovery

Runner/build/project discovery for zero-configuration JavaScript suites.

python_evidence

Validation and normalization of the Python runtime’s evidence records.

python_instrumenter

Supercov-owned Python obligation discovery.

python_project

Python project discovery and ahead-of-run obligation preparation.

python_run

Public Python coverage run lifecycle.

query_index

Immutable, versioned, fixed-layout query-index container.

ruby_evidence

Validation and normalization of the Ruby runtime’s evidence records.

ruby_instrumenter

Supercov-owned Ruby obligation discovery.

ruby_project

Ruby project discovery and ahead-of-run obligation preparation.

ruby_run

Public Ruby coverage run lifecycle.

run_currency

Whether a run is still a record of a checkout whose test-side files have moved on, judged file by file.

run_merge

Atomic, integrity-checked merging of independently executed run shards.

run_query

Agent-facing queries over persisted run metadata.

run_store

Validated local run discovery and immutable run identity.

run_view

One versioned view of a run, shared by every gate, export and report.

rust_build_cache

Exact-input stable workspace metadata for the owned Rust frontend.

rust_cargo_configuration

Exact pre-execution resolution for Cargo target runners.

rust_instrumenter

Supercov-owned Rust parsing and obligation discovery.

rust_owned_doctests

Doctests for the owned Rust frontend, measured one doctest at a time.

rust_owned_nextest

cargo nextest run for the owned Rust frontend.

rust_project

Cargo workspace discovery and isolated owned-Rust frontend preparation.

rust_run

Public, isolated Rust coverage run lifecycle.

rust_runner_attempt

Exact attempt identity exposed by Rust test runners.

rust_runtime

The region runtime for owned Rust probes, and its strict reader.

rust_test_context

Frozen Rust test-attempt context identity and supervisor collision preflight.

rust_test_runner

Stable Cargo/libtest execution for the owned Rust frontend.

rust_wasm

A Rust crate compiled to wasm that JavaScript tests load: a library wasm-bindgen exposes to a Node suite (Vitest, Jest, node:test), or the wasm of a web app a Playwright suite drives.

rust_wasm_evidence

What instrumented Rust ran in wasm, published as a Rust run of its own.

rust_worker

A Rust Worker a browser suite drives through wrangler dev.

security_candidates

Syntax-level candidates for the security surface catalog, from oxc.

served_tests

The browser tests a measured server answered: what the browser runner reported for each attempt, which a Python or Ruby server’s run takes its tests from, and the rule that gives a request naming no test to one.

source_capture

What a run captures of its sources: each file’s text at the time of the run, fingerprinted into the manifest archived with the evidence, and the check that a later query reads the same bytes.

source_discovery

Deterministic first-party JavaScript/TypeScript source discovery.

source_manifest

What a run’s sources were: each captured file’s bytes and declarations, the per-test execution record written when the run is published, and the change model that says which tests a later edit could have reached. tests affected, runs source and assertions coverage all read these.

source_tools

Tools that judge the project’s source as text.

source_units

Declaration units and comment-blind digests of one source file.

support_reach

Which tests reached which project files through the processes that served them. A suite’s mock servers are processes of their own, started by Playwright’s webServer and outside what is measured; nothing ties their files to tests, so a change to one counted for every test, and a suite measured again in full after any mock changed. Each Node process under the run notes the project files it loaded and read, and the tests it served (register.mjs, resolve-loader.mjs, runtime.mjs). A process that served requests reaches every file it loaded for each of those tests: a mock keeps state between tests, so its files are judged whole, never by route.

test_kind

A Python or Ruby test’s kind from where it lives, read as the JavaScript runtime reads one (runtime/javascript/provenance.mjs): the nearest directory that names a kind, then the file’s own name, then unit. A Rails app’s Capybara tests live in test/system or spec/features, and its request specs in spec/requests; every one of them was reported as a unit test.

test_loads

Which first-party files a JavaScript or TypeScript test file loads, read from its imports, and which test runner a configuration file belongs to.

workspace

Isolated project snapshots and crash-recoverable stable build cache.

Constants

CONTRACT_VERSION

Functions

version