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.

docker_servers

A server a browser suite starts with docker compose, built from the copy the suite runs in. The image holds the instrumented code, but nothing else crossed into the container: not the environment that tells the server’s runtime where to write, and not the directory it writes to. A docker launcher on the suite’s PATH hands each service built from the copy that environment and Supercov’s directory, mounted at the path it has outside, and records the project so the run can stop it, and read what it wrote, once the command ends.

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.

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_probe_transport

Bounded, lock-free, file-backed transport for owned Rust probe events.

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

Generated std-only runtime and strict reader for owned Rust probes.

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.

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.

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