Package-level declarations

Hashes actual loaded code and resources independently of file naming and advertised versions.

Browser evidence encoding with explicit units and bounded safe integer conversion.

Browser-native clock and animation-frame execution, independent of an application's renderer. Action-to-next-frame latency is not GPU completion time or JavaScript CPU time. Closing cancels pending callbacks, releases application closures, and rejects an incomplete run.

Complete synchronous action wall time and separate action-to-animation-frame latency. Neither distribution represents browser CPU accounting or GPU completion.

Adapter for the compiler ABI dumps already verified by each published project's checkKotlinAbi task. Keeps exact overloads and owners; source visibility differs from the separate loaded-JVM bytecode inventory. This adapter performs no performance collection or member-execution inference.

Collects completed native timestamp pairs without inferring GPU work from a CPU clock.

Selects compiled fixtures from JMH metadata without a separate corpus registry. Selection and optional deterministic work checks run before timing or creating receipt directories.

Standard JMH internal profiler that certifies the actual loaded fork before warm-up or measurement. JMH constructs this capability in the fork; it owns no clock, sampling loop or application operation. A missing or failed profiler cannot produce the required per-iteration provenance result.

JVM-only evidence validation, aggregation and comparison over standard JMH output. JMH owns collection; this API consumes preserved receipts and never times an operation itself.

Provenance adapter around standard JMH; JMH owns forks, warm-up, clocks, samples, profilers and result serialization. Consumers provide their benchmark classes, target representatives and standard CLI options, rather than another engine. JMH is a consumer-supplied dependency; this test-only adapter does not add it to the kit's runtime POM.

Exact expected matrices from JMH's generated benchmark registry, without another annotation or timing engine. Consumers register fixture classes, explicit standard modes and optional subsets of compiled parameter values.

Discovers the JVM-visible public/protected binary surface from the artifacts actually loaded by a host. Includes Kotlin declarations exposed publicly in bytecode; source-level visibility is not inferred. Discovery does not initialize classes and rejects shadowed resources, origins, or unresolved linkage.

Optional fixture-owned supplemental report, discovered through a static operationReport() hook. Use JvmPerformanceRunner.warmup and JvmPerformanceRunner.sequence on the fixture owner thread. Preparation, assertions, serialization and surviving-resource cleanup belong outside each sample; required lifecycle work belongs inside the declared complete operation.

Frozen logical operation identity and its complete original JMH method/parameter binding. A sample contains operationsPerSample complete operations; counters normalize by samples, so batching remains explicit rather than being presented as an individual operation. boundary describes required steps and lifecycle work inside the sample.

Optional compiled operation-report connection to a completed frozen JMH invocation. The existing runner owns sampling and the existing report processor owns comparison. Original JMH archives, loaded identities and inputs remain mandatory independent evidence.

Shared JVM validation and aggregation for detached collector-bound evidence. Consumers provide workload-specific conditions; they do not implement another comparison engine.

Reads caller-declared external fixture files from a UTF-8 standard JDK properties manifest. Gradle can register resolved control libraries and native archives without adding consumer hashing logic.

Owner-thread JDK timing, allocation, heap-boundary, and process-GC collector. Setup, assertions, and evidence serialization belong outside sample boundaries. Unsupported metrics remain null and failed samples cannot publish successful evidence.

Shared processing of fixed CPU and native phase reports from immutable raw evidence. Consumers register conditions, metrics and untimed work assertions, never their own aggregation engine.

Shared synchronous execution; consumers describe operations rather than implementing sample loops.

Collects one synchronous operation per application-owned scheduling opportunity. The host supplies ticks or callbacks; warm-up counts, sample boundaries and incomplete evidence belong to the kit. Construct, advance, complete and close on the same physical owner thread. An operation must release its own temporary resources, including when warm-up fails. Closing releases callbacks and collector storage, without closing the application fixture.

Kit-owned sample boundaries for interleaved historical workloads with untimed per-sample setup. Consumers choose which operation to time; they cannot publish an incomplete or failed sequence.

Bounded provenance from the actual loaded classes, without substituting standalone distribution JARs. Missing locations remain explicit failures rather than inferred hashes.

Actual Fabric extraction/render adapter, confined to the measured screen's client thread. Event callbacks and native counters belong to the kit; consumers supply only state changes. GPU completion, model mutation, readiness, and evidence storage are outside extraction samples. Complete operation frames include diagnostic instrumentation and frame pacing, rather than uninstrumented application latency.

Verifies actual CPU and native loaded class bytes without trusting archive names or versions. The consumer supplies its expected module inventory; the kit owns file and class-tree verification.

Application data and evidence hooks outside native extraction samples. The kit owns invocation order, settling, deadlines, counters, and callback cleanup. Hooks execute on the screen's owner thread and failures invalidate the whole interval.

Actual native work and retained payload; missing adapter metrics cannot become zero work.

Monotonic preparation/execution budget, independent of timed sample distributions. Child sections retain an earlier enclosing deadline, including one that has already expired.

Java-only entry point for collector-bound evidence requests supplied by consumers or Gradle tasks. The sole argument is a UTF-8 JSON request file; JMH and the existing kit own the measurement engine. Validation failures propagate to a nonzero process exit and cannot create a successful output.

Detached JVM report serialization, shared by every consumer and host adapter.

Consumer-declared registration for a fixed report workload, independent of collection and comparison. Variant report fields may change between runtime candidates, but must remain identical within a side. Phase conditions must include sample counts and every fixture invariant required by that workload.

Explicit metric projection from an existing report, with optional per-sample normalization. Unavailable measurements remain unavailable; scale converts declared units without another timer.

One complete measured interval and its last application-owned result, without frame history.

Bounded aggregation of complete per-sample runtime diagnostics on the application's owner thread. Retired node identities are discarded after each snapshot, outside the measured operation. A single overflowing sample still fails; global counts never stand in for truncated node evidence.

Owner-thread monitor over the actual measured Strata instance, with no runtime-version substitution.