From 1ecbeab5f1a4f876e9a30a8e9697990b226d2e3a Mon Sep 17 00:00:00 2001
From: Ioannis Makris <imak@imak.gr>
Date: Wed, 4 Nov 2026 02:06:00 +0100
Subject: [PATCH 1/5] Establish repeatable plot workloads and paired benchmark
 comparisons

Recover the completed benchmark baseline from the original local work.
Source tree is byte-identical to original commit 88d459dbbad9cff1a292b3ffa87be97970d371e6, including the initial workload suite and unavailable-counter handling.

Original commits are preserved in vnm_plot-benchmarks-2026-11-04.zip; this publication uses a new commit identity because direct Git push authentication was unavailable.
---
 benchmark/CMakeLists.txt                  |  21 +
 benchmark/README.md                       | 136 +++++
 benchmark/include/benchmark_data_source.h |  10 +-
 benchmark/include/benchmark_profiler.h    |  26 +
 benchmark/include/benchmark_window.h      |  13 +
 benchmark/src/benchmark_window.cpp        | 111 +++-
 benchmark/src/main.cpp                    |  65 ++-
 benchmark/tools/run_suite.py              | 664 ++++++++++++++++++++++
 benchmark/tools/test_phase_trace_flush.py |   5 +-
 benchmark/tools/test_run_suite.py         | 146 +++++
 benchmark/tools/validate_workloads.py     | 103 ++++
 tests/test_core_algo.cpp                  |  74 +++
 12 files changed, 1348 insertions(+), 26 deletions(-)
 create mode 100644 benchmark/tools/run_suite.py
 create mode 100644 benchmark/tools/test_run_suite.py
 create mode 100644 benchmark/tools/validate_workloads.py

diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index d4a26dd4..17c3acc1 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -309,4 +309,25 @@ set_tests_properties(benchmark_shared_frame_pipeline PROPERTIES
     ENVIRONMENT "PYTHONDONTWRITEBYTECODE=1"
 )
 
+add_test(
+    NAME benchmark_workload_contracts
+    COMMAND "${Python3_EXECUTABLE}"
+        "${CMAKE_CURRENT_SOURCE_DIR}/tools/validate_workloads.py"
+        --executable "$<TARGET_FILE:vnm_plot_benchmark>"
+)
+set_tests_properties(benchmark_workload_contracts PROPERTIES
+    TIMEOUT 90
+    ENVIRONMENT "PYTHONDONTWRITEBYTECODE=1"
+)
+
+add_test(
+    NAME benchmark_suite_validation
+    COMMAND "${Python3_EXECUTABLE}" -m unittest discover
+        -s "${CMAKE_CURRENT_SOURCE_DIR}/tools" -p test_run_suite.py
+)
+set_tests_properties(benchmark_suite_validation PROPERTIES
+    TIMEOUT 15
+    ENVIRONMENT "PYTHONDONTWRITEBYTECODE=1"
+)
+
 endif()
diff --git a/benchmark/README.md b/benchmark/README.md
index f2aa398d..30c9b135 100644
--- a/benchmark/README.md
+++ b/benchmark/README.md
@@ -45,3 +45,139 @@ to measured frames.
 
 On Windows, benchmark file operations support extended-length native paths
 while reports keep their ordinary logical path spelling.
+
+## Repeatable workload suite
+
+Build the existing executable and its contract tests with Qt 6.12 and the
+dependencies described in [Building](../docs/building.md):
+
+```bash
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release \
+  -DVNM_PLOT_BUILD_BENCHMARK=ON -DVNM_PLOT_BUILD_TESTS=ON
+cmake --build build --config Release --target vnm_plot_benchmark
+python3 benchmark/tools/run_suite.py \
+  --candidate build/benchmark/vnm_plot_benchmark \
+  --graphics-backend opengl --output-dir results/baseline
+```
+
+Use `d3d11` on Windows, `metal` on macOS, or another explicitly supported API.
+`native` accepts Qt's platform default but rejects Null fallback. On a host
+without raster rendering, `QT_QPA_PLATFORM=offscreen` and
+`--graphics-backend null` exercise the production CPU pipeline only. Null
+does not execute shaders, rasterize, measure GPU work, or validate pixels.
+
+The suite runs these named cases, selectable with `--cases NAME ...`:
+
+| Case | Purpose |
+|---|---|
+| `warm-line-1`, `warm-line-8`, `warm-line-32` | Settled frame cost as series count grows |
+| `dense-line-8` | 100,000 visible samples per series, ten times the ordinary case |
+| `warm-area-8`, `warm-dots-8` | Other production primitive paths |
+| `warm-stacked-area-8` | Stack composition and reuse |
+| `pan-line-8` | A quarter-width window moving across fixed history |
+| `zoom-line-8` | A centered view changing from 10% to 100% of history |
+| `append-line-8` | Exactly 16 new samples per series before each measured frame |
+| `wrap-line-8` | The same publication schedule into a full ring, including split spans |
+| `warm-line-8-no-text` | Control for text/layout changes |
+| `warm-line-8-conservative` | Callbacks without a declared stable semantic identity |
+
+Ordinary cases contain 10,000 samples per series. The seed, dimensions, series
+count, rates, data/style, warmup and measured frames are explicit in every
+command/report. The dense case also increases sample rate, keeping its entire
+history within the ten-second view instead of only increasing invisible data.
+Preview rendering is enabled in the suite; individual runs can use
+`--no-preview` to isolate the main pane.
+
+The suite passes `--stable-access` except in the conservative control. The
+benchmark's stateless callbacks then declare their actual immutable semantics
+through the public policy API, allowing production range-cache reuse. A
+byte-layout key alone does not establish callback semantics. This is a
+workload distinction, not a production performance improvement. The original
+ad-hoc conservative default remains available without the flag.
+
+Panning and zooming use a 120-frame triangular cycle. Append/motion require
+`--static --frames N`; warmup uses the initial data and view, and the measured
+sequence does not depend on the number of warmup frames. `--static` means
+prefilled data with no producer thread; `--append-per-frame` then advances it
+synchronously before each render timer starts. Synthetic generation and
+publication cost is reported separately as `benchmark.workload.publish_ms`.
+The existing time-paced producer mode remains available for contention and
+live-rate experiments, but is not used for paired performance comparisons.
+
+Input schedules are deterministic. Label fades still use elapsed real time,
+so motion/update cases may retain different outgoing labels on differently
+paced runs. They are not pixel-identical frame sequences. Settled cases are
+the strongest timing controls; fixed-clock CoreAlgo tests cover fade behavior.
+The sources currently expose LOD 0 only, so this suite does not cover LOD
+switching, custom layers, or the Qt Quick event/synchronization loop.
+
+## Compare an optimization
+
+Build baseline and candidate with the **same benchmark code, compiler,
+dependencies and configuration**. Keep both executables, then run:
+
+```bash
+python3 benchmark/tools/run_suite.py \
+  --baseline /absolute/path/to/baseline/vnm_plot_benchmark \
+  --candidate /absolute/path/to/candidate/vnm_plot_benchmark \
+  --graphics-backend opengl --output-dir results/comparison \
+  --repetitions 5 --warmup-frames 30 --frames 240
+```
+
+Each process is a replicate. The runner executes sequentially, alternates
+baseline/candidate order by repetition, preserves every raw report and log,
+and rejects failed frames, wrong publication/occupancy/overwrite counts,
+unexpected static uploads/scans, mismatched metadata or backend fallback.
+It records executable hashes and host/renderer details. Record the exact
+source/dependency revisions alongside results: a binary's enclosing checkout
+at run time does not prove what was compiled into it.
+
+`summary.md` gives medians of per-process means and p95s. `summary.json` also
+contains paired changes, IQR, min/max, counter totals and inclusive scope
+costs. `manifest.json` links raw reports and preserves run order. Negative
+paired percentages mean lower cost. Frame samples are not pooled as independent
+replicates, and spread is not presented as a confidence interval. There are
+no machine-dependent performance thresholds in CTest.
+
+Use a second run with `--frame-timing-only` to check whether a result survives
+without internal renderer/source profiling. It retains outer frame timings
+and render-thread C++ allocation accounting, plus exact publication counts.
+Internal counters/scopes are absent in this mode and are not inferred as zero.
+Keep internal-profiling mode identical within each comparison.
+
+### Measurement boundaries
+
+- `benchmark.frame.total_ms` is offscreen frame **wall time**, including
+  begin/end-frame, production planning/layout/text/series preparation,
+  recording and `--finish`. It is not application FPS or isolated CPU time.
+- `benchmark.frame.submission_ms` includes QRhi begin/end calls, which may
+  synchronize. `gpu_finish_ms` is the extra finish call; it is not a GPU timer.
+- Internal named scopes are inclusive and aggregated by full scope name in
+  the raw JSON `scopes` map. Do not sum parent and child times.
+- C++ allocation counters cover the measured render thread and exclude
+  profiler storage. They do not count all `malloc` calls, other threads, GPU
+  memory, or retained memory. QRhi buffer creation has separate counters.
+- Setup/first submission and warmup are separate from measured frames.
+  Existing font/disk caches can affect cold results; the suite reports warm
+  frames and does not claim controlled cold-start performance.
+- Timing runs disable readback. Run `--pixel-checksum` separately on a raster
+  backend and compare appropriate stable frames when validating a change.
+  Faster execution alone is not evidence that rendering stayed correct.
+
+The offscreen runner consumes measured value-axis width feedback, as the
+shipping widget does. Reusing the initial width would cause layout misses in
+otherwise settled frames; the workload contract test checks this invariant.
+
+## Maintained checks
+
+With benchmark tests enabled, CTest includes `benchmark_workload_contracts`
+and `benchmark_suite_validation`. They check actual fixed/pan/zoom/publication
+behavior, settled layout/range/upload reuse, frame-only mode, invalid input,
+and rejection of incomplete or incomparable results. The phase-flush test
+uses Null by default because it tests durable output and external termination;
+native smoke/readback tests retain their raster backend requirement.
+
+```bash
+QT_QPA_PLATFORM=offscreen ctest --test-dir build --output-on-failure \
+  -R '^(benchmark_workload_contracts|benchmark_suite_validation|benchmark_shared_frame_pipeline|benchmark_phase_trace_flush)$'
+```
diff --git a/benchmark/include/benchmark_data_source.h b/benchmark/include/benchmark_data_source.h
index 372feb9c..f2c96cf9 100644
--- a/benchmark/include/benchmark_data_source.h
+++ b/benchmark/include/benchmark_data_source.h
@@ -113,7 +113,7 @@ class Benchmark_data_source : public vnm::plot::Data_source {
 /// Create a Data_access_policy for Bar_sample. The renderer owns the GPU-side
 /// sample layout (gpu_sample_t) and rebases timestamps on upload, so the
 /// policy only exposes value extractors plus a stable layout_key for caching.
-inline vnm::plot::Data_access_policy make_bar_access_policy() {
+inline vnm::plot::Data_access_policy make_bar_access_policy(bool stable_semantics = false) {
     vnm::plot::Data_access_policy policy;
 
     policy.get_timestamp = [](const void* sample) -> std::int64_t {
@@ -130,6 +130,9 @@ inline vnm::plot::Data_access_policy make_bar_access_policy() {
     };
 
     policy.layout_key = k_bar_sample_layout_key;
+    if (stable_semantics) {
+        policy.set_semantics_key(k_bar_sample_layout_key, 1);
+    }
 
     return policy;
 }
@@ -137,7 +140,7 @@ inline vnm::plot::Data_access_policy make_bar_access_policy() {
 /// Create a Data_access_policy for Trade_sample. The renderer owns the GPU-side
 /// sample layout (gpu_sample_t) and rebases timestamps on upload, so the
 /// policy only exposes value extractors plus a stable layout_key for caching.
-inline vnm::plot::Data_access_policy make_trade_access_policy() {
+inline vnm::plot::Data_access_policy make_trade_access_policy(bool stable_semantics = false) {
     vnm::plot::Data_access_policy policy;
 
     policy.get_timestamp = [](const void* sample) -> std::int64_t {
@@ -154,6 +157,9 @@ inline vnm::plot::Data_access_policy make_trade_access_policy() {
     };
 
     policy.layout_key = k_trade_sample_layout_key;
+    if (stable_semantics) {
+        policy.set_semantics_key(k_trade_sample_layout_key, 1);
+    }
 
     return policy;
 }
diff --git a/benchmark/include/benchmark_profiler.h b/benchmark/include/benchmark_profiler.h
index daa99c7e..eab5e9d8 100644
--- a/benchmark/include/benchmark_profiler.h
+++ b/benchmark/include/benchmark_profiler.h
@@ -357,6 +357,32 @@ class Benchmark_profiler : public vnm::plot::Profiler {
             }
             ofs << "\n";
         }
+        ofs << "  },\n  \"scopes\": {\n";
+        // Named scope totals are inclusive. Aggregate the same full scope name
+        // across parents; never add parent and child durations into frame time.
+        std::map<std::string, Scope_stats> scopes;
+        const auto collect_scopes = [&](const auto& self, const Scope_stats& parent) -> void {
+            for (const auto& [name, child] : parent.children) {
+                auto& total = scopes[name];
+                total.call_count += child->call_count;
+                total.total_ms += child->total_ms;
+                total.min_ms = std::min(total.min_ms, child->min_ms);
+                total.max_ms = std::max(total.max_ms, child->max_ms);
+                self(self, *child);
+            }
+        };
+        collect_scopes(collect_scopes, m_root);
+        std::size_t scope_index = 0;
+        for (const auto& [name, stats] : scopes) {
+            ofs << "    \"" << json_escape(name) << "\": {\n";
+            ofs << "      \"count\": " << stats.call_count << ",\n";
+            ofs << "      \"total_ms\": " << json_number(stats.total_ms) << ",\n";
+            ofs << "      \"mean_ms\": " << json_number(stats.call_count
+                ? stats.total_ms / static_cast<double>(stats.call_count) : 0.0) << ",\n";
+            ofs << "      \"min_ms\": " << json_number(stats.min_ms) << ",\n";
+            ofs << "      \"max_ms\": " << json_number(stats.max_ms) << "\n    }";
+            ofs << (++scope_index < scopes.size() ? ",\n" : "\n");
+        }
         ofs << "  }\n}\n";
         if (!ofs) {
             throw std::runtime_error("cannot write raw benchmark report: " + output_path.string());
diff --git a/benchmark/include/benchmark_window.h b/benchmark/include/benchmark_window.h
index 8d70e027..95caba57 100644
--- a/benchmark/include/benchmark_window.h
+++ b/benchmark/include/benchmark_window.h
@@ -82,6 +82,18 @@ struct Benchmark_config {
     // skips the producer thread.
     bool static_data = false;
     std::size_t static_sample_count = 10'000;
+    // Deterministic offscreen workloads start from the static prefill. A fixed
+    // publication per measured frame avoids faster builds seeing less data.
+    std::size_t append_per_frame = 0;
+    std::string view_motion = "fixed";  // fixed|pan|zoom, 120-frame cycle
+    bool preview_enabled = true;
+    // Keep outer frame timing/allocation accounting, without renderer/source
+    // profiling. Use alongside diagnostic runs to expose instrumentation cost.
+    bool internal_profiling = true;
+    // The synthetic callbacks are immutable. Opt into their explicit semantic
+    // identity to exercise normal range-cache reuse, retaining the legacy
+    // conservative callable path as a separate benchmark control.
+    bool stable_access = false;
     // Line thickness in pixels (default 1.5 for animated runs; bumped via
     // --line-px when comparing visuals so segments are easy to inspect).
     double line_width_px = 1.5;
@@ -207,6 +219,7 @@ class Benchmark_rhi_offscreen_runner
     void fill_static_data();
     bool initialize_rhi(std::string& error_message);
     bool render_frame(std::string& error_message, bool measured);
+    void append_frame_samples();
     void record_final_statistics(double measured_seconds);
     void record_phase(const char* phase, std::size_t frame = 0) const;
 
diff --git a/benchmark/src/benchmark_window.cpp b/benchmark/src/benchmark_window.cpp
index 83045ccc..3aa8f28b 100644
--- a/benchmark/src/benchmark_window.cpp
+++ b/benchmark/src/benchmark_window.cpp
@@ -135,13 +135,17 @@ double steady_clock_resolution_ns()
     return std::isfinite(resolution) ? resolution : 0.0;
 }
 
-void ensure_interval_observations(Benchmark_profiler& profiler)
+void ensure_interval_observations(Benchmark_profiler& profiler, bool internal_profiling)
 {
     profiler.ensure_observation("benchmark.producer.lock_wait_ns");
-    profiler.ensure_observation("renderer.series_window.monotonicity_scan_count");
-    profiler.ensure_observation("renderer.series_window.monotonicity_scan_samples");
-    profiler.ensure_observation("renderer.frame.gpu_buffer_allocation_bytes");
-    profiler.ensure_observation("renderer.frame.gpu_buffer_allocation_count");
+    if (internal_profiling) {
+        profiler.ensure_observation("renderer.series_window.monotonicity_scan_count");
+        profiler.ensure_observation("renderer.series_window.monotonicity_scan_samples");
+        profiler.ensure_observation("renderer.auto_range.query_count");
+        profiler.ensure_observation("renderer.auto_range.range_scan_count");
+        profiler.ensure_observation("renderer.frame.gpu_buffer_allocation_bytes");
+        profiler.ensure_observation("renderer.frame.gpu_buffer_allocation_count");
+    }
     profiler.ensure_observation("benchmark.frame.cpu_allocation_bytes");
     profiler.ensure_observation("benchmark.frame.cpu_allocation_count");
 }
@@ -465,11 +469,11 @@ void Benchmark_rhi_window::setup_series()
 
         if (m_config.data_type == "Trades") {
             series->set_data_source_ref(*m_trade_sources[index]);
-            series->access = make_trade_access_policy();
+            series->access = make_trade_access_policy(m_config.stable_access);
         }
         else {
             series->set_data_source_ref(*m_bar_sources[index]);
-            series->access = make_bar_access_policy();
+            series->access = make_bar_access_policy(m_config.stable_access);
         }
 
         if (style == "Dots") {
@@ -589,7 +593,7 @@ void Benchmark_rhi_window::record_final_statistics()
     m_profiler.record_observation(
         "benchmark.memory.process_high_water_bytes",
         static_cast<double>(process_memory_high_water_bytes()));
-    ensure_interval_observations(m_profiler);
+    ensure_interval_observations(m_profiler, m_config.internal_profiling);
 }
 
 Benchmark_rhi_offscreen_runner::Benchmark_rhi_offscreen_runner(const Benchmark_config& config)
@@ -615,14 +619,15 @@ Benchmark_rhi_offscreen_runner::~Benchmark_rhi_offscreen_runner()
 
 void Benchmark_rhi_offscreen_runner::setup_data_source()
 {
+    auto* profiler = m_config.internal_profiling ? &m_profiler : nullptr;
     if (m_config.data_type == "Trades") {
         m_trade_buffers.reserve(m_config.series_count);
         m_trade_sources.reserve(m_config.series_count);
         for (std::size_t index = 0; index < m_config.series_count; ++index) {
             auto buffer = std::make_unique<Ring_buffer<Trade_sample>>(m_config.ring_capacity);
-            buffer->set_profiler(&m_profiler);
+            buffer->set_profiler(profiler);
             auto source = std::make_unique<Benchmark_data_source<Trade_sample>>(*buffer);
-            source->set_profiler(&m_profiler);
+            source->set_profiler(profiler);
             m_trade_buffers.push_back(std::move(buffer));
             m_trade_sources.push_back(std::move(source));
         }
@@ -632,9 +637,9 @@ void Benchmark_rhi_offscreen_runner::setup_data_source()
         m_bar_sources.reserve(m_config.series_count);
         for (std::size_t index = 0; index < m_config.series_count; ++index) {
             auto buffer = std::make_unique<Ring_buffer<Bar_sample>>(m_config.ring_capacity);
-            buffer->set_profiler(&m_profiler);
+            buffer->set_profiler(profiler);
             auto source = std::make_unique<Benchmark_data_source<Bar_sample>>(*buffer);
-            source->set_profiler(&m_profiler);
+            source->set_profiler(profiler);
             m_bar_buffers.push_back(std::move(buffer));
             m_bar_sources.push_back(std::move(source));
         }
@@ -646,7 +651,8 @@ void Benchmark_rhi_offscreen_runner::setup_rendering()
     m_frame_renderer->initialize();
     m_snapshot->adjusted_font_px        = k_adjusted_font_px;
     m_snapshot->base_label_height_px    = k_base_label_height_px;
-    m_snapshot->adjusted_preview_height = k_adjusted_preview_height;
+    m_snapshot->adjusted_preview_height = m_config.preview_enabled
+        ? k_adjusted_preview_height : 0.0;
     m_snapshot->vbar_width_pixels       = k_vbar_width_pixels;
 
     m_snapshot->config.dark_mode = true;
@@ -661,10 +667,13 @@ void Benchmark_rhi_offscreen_runner::setup_rendering()
     m_snapshot->config.point_diameter_px = m_config.point_diameter_px;
     m_snapshot->config.font_size_px = k_adjusted_font_px;
     m_snapshot->config.base_label_height_px = k_base_label_height_px;
-    m_snapshot->config.preview_height_px = k_adjusted_preview_height;
+    m_snapshot->config.preview_height_px = m_snapshot->adjusted_preview_height;
+    m_snapshot->config.preview_visibility = m_config.preview_enabled ? 1.0 : 0.0;
     m_snapshot->config.format_timestamp = format_benchmark_timestamp;
-    m_snapshot->config.profiler =
-        std::shared_ptr<vnm::plot::Profiler>(&m_profiler, [](vnm::plot::Profiler*) {});
+    if (m_config.internal_profiling) {
+        m_snapshot->config.profiler =
+            std::shared_ptr<vnm::plot::Profiler>(&m_profiler, [](vnm::plot::Profiler*) {});
+    }
 }
 
 void Benchmark_rhi_offscreen_runner::setup_series()
@@ -681,11 +690,11 @@ void Benchmark_rhi_offscreen_runner::setup_series()
 
         if (m_config.data_type == "Trades") {
             series->set_data_source_ref(*m_trade_sources[index]);
-            series->access = make_trade_access_policy();
+            series->access = make_trade_access_policy(m_config.stable_access);
         }
         else {
             series->set_data_source_ref(*m_bar_sources[index]);
-            series->access = make_bar_access_policy();
+            series->access = make_bar_access_policy(m_config.stable_access);
         }
 
         if (style == "Dots") {
@@ -1039,7 +1048,8 @@ bool Benchmark_rhi_offscreen_runner::render_frame(
         ? static_cast<vnm::plot::Data_source*>(m_trade_sources.front().get())
         : static_cast<vnm::plot::Data_source*>(m_bar_sources.front().get());
     {
-        VNM_PLOT_PROFILE_SCOPE(&m_profiler, "benchmark.update_time_range");
+        VNM_PLOT_PROFILE_SCOPE(
+            m_snapshot->config.profiler.get(), "benchmark.update_time_range");
         update_time_range_from_source(
             source,
             m_config.data_type,
@@ -1047,11 +1057,33 @@ bool Benchmark_rhi_offscreen_runner::render_frame(
             m_snapshot->data_cfg.t_max,
             m_snapshot->data_cfg.t_available_min);
         m_snapshot->data_cfg.t_available_max = m_snapshot->data_cfg.t_max;
+        if (m_config.view_motion != "fixed") {
+            // Warmup settles at the initial view. Measured inputs depend only
+            // on the frame index, never machine speed or the warmup count.
+            const std::size_t step = measured ? (m_measured_frame_count + 1) % 120 : 0;
+            const long double phase = static_cast<long double>(
+                step <= 60 ? step : 120 - step) / 60.0L;
+            const auto first = m_snapshot->data_cfg.t_available_min;
+            const auto last = m_snapshot->data_cfg.t_available_max;
+            const long double span = static_cast<long double>(last) - first;
+            const long double fraction = m_config.view_motion == "pan"
+                ? 0.25L : 0.10L + 0.90L * phase;
+            const long double offset = m_config.view_motion == "pan"
+                ? (1.0L - fraction) * phase : (1.0L - fraction) * 0.5L;
+            m_snapshot->data_cfg.t_min = first + static_cast<std::int64_t>(span * offset);
+            m_snapshot->data_cfg.t_max = std::max(
+                m_snapshot->data_cfg.t_min + 1,
+                first + static_cast<std::int64_t>(span * (offset + fraction)));
+        }
     }
 
-    m_frame_renderer->render(*m_snapshot, m_rhi.get(), m_render_target.get(), cb);
+    const auto result = m_frame_renderer->render(
+        *m_snapshot, m_rhi.get(), m_render_target.get(), cb);
+    // Plot_widget consumes this feedback too. Keeping the initial width here
+    // makes every otherwise static frame miss the settled layout cache.
+    m_snapshot->vbar_width_pixels = result.feedback.measured_vbar_width;
     m_last_prepare_ms = m_profiler.last_series_prepare_ms();
-    if (measured) {
+    if (measured && m_config.internal_profiling) {
         m_profiler.record_observation("benchmark.planning.time_ms", m_last_prepare_ms);
     }
 
@@ -1147,12 +1179,44 @@ bool Benchmark_rhi_offscreen_runner::render_frame(
             "benchmark.frame.cpu_allocation_bytes",
             static_cast<double>(allocations.bytes));
         m_profiler.record_observation("benchmark.frame.total_ms", frame_ms);
+        m_profiler.record_observation(
+            "benchmark.view.t_min_ns", static_cast<double>(m_snapshot->data_cfg.t_min));
+        m_profiler.record_observation(
+            "benchmark.view.t_max_ns", static_cast<double>(m_snapshot->data_cfg.t_max));
+        m_profiler.record_observation(
+            "benchmark.view.vbar_width_px", m_snapshot->vbar_width_pixels);
         m_profiler.record_counter("benchmark.frame.output_count");
         ++m_measured_frame_count;
     }
     return true;
 }
 
+void Benchmark_rhi_offscreen_runner::append_frame_samples()
+{
+    if (m_config.append_per_frame == 0) {
+        return;
+    }
+    const auto started = std::chrono::steady_clock::now();
+    for (std::size_t i = 0; i < m_config.append_per_frame; ++i) {
+        if (m_config.data_type == "Trades") {
+            const auto sample = m_generator.next_trade();
+            for (auto& buffer : m_trade_buffers) {
+                buffer->push(sample);
+            }
+        }
+        else {
+            const auto sample = m_generator.next_bar();
+            for (auto& buffer : m_bar_buffers) {
+                buffer->push(sample);
+            }
+        }
+    }
+    m_samples_generated.fetch_add(m_config.append_per_frame);
+    m_profiler.record_observation("benchmark.workload.publish_ms",
+        std::chrono::duration<double, std::milli>(
+            std::chrono::steady_clock::now() - started).count());
+}
+
 bool Benchmark_rhi_offscreen_runner::run(std::string& error_message)
 {
     m_phase_trace_started = std::chrono::steady_clock::now();
@@ -1253,6 +1317,9 @@ bool Benchmark_rhi_offscreen_runner::run(std::string& error_message)
     const auto duration = std::chrono::duration<double>(m_config.duration_seconds);
 
     const auto render_measured_frame = [&](std::size_t frame) {
+        // Synthetic generation/publication is deliberately outside the render
+        // timer and allocation scope, and has its own reported cost.
+        append_frame_samples();
         if (render_frame(error_message, true)) {
             return true;
         }
@@ -1317,7 +1384,7 @@ void Benchmark_rhi_offscreen_runner::record_final_statistics(double measured_sec
     m_profiler.record_observation(
         "benchmark.memory.process_high_water_bytes",
         static_cast<double>(process_memory_high_water_bytes()));
-    ensure_interval_observations(m_profiler);
+    ensure_interval_observations(m_profiler, m_config.internal_profiling);
 }
 
 }  // namespace vnm::benchmark
diff --git a/benchmark/src/main.cpp b/benchmark/src/main.cpp
index 762f3b3c..0be57c25 100644
--- a/benchmark/src/main.cpp
+++ b/benchmark/src/main.cpp
@@ -18,6 +18,7 @@
 #include <array>
 #include <cctype>
 #include <chrono>
+#include <cmath>
 #include <cstdlib>
 #include <filesystem>
 #include <iostream>
@@ -94,6 +95,12 @@ void print_usage(const char* program_name)
               << "  --render-style <style>  dots|line|area (default: dots for trades, area for bars)\n"
               << "  --static                Skip the generator and render a deterministic static window\n"
               << "  --static-samples <n>    Samples per static series (default: 10000)\n"
+              << "  --append-per-frame <n> Publish n samples/series before each measured frame\n"
+              << "  --view-motion <mode>   fixed|pan|zoom (deterministic 120-frame cycle)\n"
+              << "                         Append/motion require --static and --frames\n"
+              << "  --no-preview            Disable the preview pane\n"
+              << "  --frame-timing-only     Disable internal profiling; retain outer frame metrics\n"
+              << "  --stable-access         Declare immutable sample accessor semantics for caching\n"
               << "  --line-px <pixels>      Line thickness for line/area rendering (default: 1.5)\n"
               << "  --point-px <pixels>     Dot diameter for dots rendering (default: 1.0)\n"
               << "  --output-dir <path>     Output directory for reports (default: current dir)\n"
@@ -221,6 +228,26 @@ Parse_result parse_args(int argc, char* argv[])
                 config.static_sample_count = std::stoull(argv[++i]);
             }
             else
+            if (arg == "--append-per-frame" && i + 1 < argc) {
+                config.append_per_frame = std::stoull(argv[++i]);
+            }
+            else
+            if (arg == "--view-motion" && i + 1 < argc) {
+                config.view_motion = argv[++i];
+            }
+            else
+            if (arg == "--no-preview") {
+                config.preview_enabled = false;
+            }
+            else
+            if (arg == "--frame-timing-only") {
+                config.internal_profiling = false;
+            }
+            else
+            if (arg == "--stable-access") {
+                config.stable_access = true;
+            }
+            else
             if (arg == "--line-px" && i + 1 < argc) {
                 config.line_width_px = std::stod(argv[++i]);
             }
@@ -357,7 +384,7 @@ std::string validate_config(const vnm::benchmark::Benchmark_config& config)
     if (config.duration_seconds > 3600.0) {
         return "Duration cannot exceed 3600 seconds (1 hour)";
     }
-    if (config.rate < 1.0) {
+    if (!std::isfinite(config.rate) || config.rate < 1.0) {
         return "Rate must be at least 1 sample/sec (got " +
                std::to_string(config.rate) + ")";
     }
@@ -380,6 +407,27 @@ std::string validate_config(const vnm::benchmark::Benchmark_config& config)
     if (config.static_sample_count < 2 || config.static_sample_count > config.ring_capacity) {
         return "Static sample count must be between 2 and the ring capacity";
     }
+    if (config.view_motion != "fixed" && config.view_motion != "pan" &&
+        config.view_motion != "zoom") {
+        return "View motion must be fixed, pan, or zoom";
+    }
+    if (config.append_per_frame > config.ring_capacity) {
+        return "Append samples per frame cannot exceed the ring capacity";
+    }
+    if ((config.append_per_frame > 0 || config.view_motion != "fixed") &&
+        (!config.static_data || config.measured_frames == 0)) {
+        return "Deterministic append/motion require --static and an exact --frames count";
+    }
+    if (config.append_per_frame > 0 && config.view_motion != "fixed") {
+        return "Choose either append-per-frame or view motion";
+    }
+    const long double generated_samples = config.static_sample_count +
+        static_cast<long double>(config.append_per_frame) * config.measured_frames;
+    if (config.append_per_frame > 0 &&
+        generated_samples * std::llround(1.0e9 / config.rate) >=
+            static_cast<long double>(std::numeric_limits<std::int64_t>::max())) {
+        return "Deterministic publication would exceed the timestamp range";
+    }
     if (config.volatility < 0.0 || config.volatility > 1.0) {
         return "Volatility must be between 0.0 and 1.0 (got " +
                std::to_string(config.volatility) + ")";
@@ -425,6 +473,10 @@ void print_config_summary(const vnm::benchmark::Benchmark_config& config, std::o
        << "  Series:       " << config.series_count << "\n"
        << "  Static data:  " << (config.static_data ? "yes" : "no")
        << " (" << config.static_sample_count << " samples/series)\n"
+       << "  Append/frame: " << config.append_per_frame << " samples/series\n"
+       << "  View motion:  " << config.view_motion << "\n"
+       << "  Preview:      " << (config.preview_enabled ? "yes" : "no") << "\n"
+       << "  Profiling:    " << (config.internal_profiling ? "internal + frame" : "frame only") << "\n"
        << "  Volatility:   " << config.volatility << "\n"
        << "  Seed:         " << config.seed << "\n"
        << "  Output dir:   " << config.output_directory << "\n"
@@ -580,6 +632,17 @@ int main(int argc, char* argv[])
         meta.reproduction["sample_count"] = std::to_string(config.sample_count);
         meta.reproduction["seed"] = std::to_string(config.seed);
         meta.reproduction["series_count"] = std::to_string(config.series_count);
+        meta.reproduction["stack_series"] = config.stack_series ? "true" : "false";
+        meta.reproduction["workload_contract_version"] = "2";
+        meta.reproduction["append_per_frame"] = std::to_string(config.append_per_frame);
+        meta.reproduction["view_motion"] = config.view_motion;
+        meta.reproduction["preview_enabled"] = config.preview_enabled ? "true" : "false";
+        meta.reproduction["internal_profiling"] = config.internal_profiling ? "true" : "false";
+        meta.reproduction["access_semantics"] = config.stable_access ? "stable" : "conservative";
+        meta.reproduction["pixel_readback"] = config.capture_pixel_checksum ? "true" : "false";
+        meta.reproduction["volatility"] = std::to_string(config.volatility);
+        meta.reproduction["line_width_px"] = std::to_string(config.line_width_px);
+        meta.reproduction["point_diameter_px"] = std::to_string(config.point_diameter_px);
         meta.reproduction["show_text"] = config.show_text ? "true" : "false";
         meta.reproduction["static_data"] = config.static_data ? "true" : "false";
         meta.reproduction["static_sample_count"] =
diff --git a/benchmark/tools/run_suite.py b/benchmark/tools/run_suite.py
new file mode 100644
index 00000000..ba726926
--- /dev/null
+++ b/benchmark/tools/run_suite.py
@@ -0,0 +1,664 @@
+#!/usr/bin/env python3
+"""Run repeatable vnm_plot workloads and compare paired executable runs.
+
+Each process is one replicate. Frames from a process are not treated as
+independent replicates. The executables must contain the same version of the
+benchmark harness; only the library implementation under study should differ.
+"""
+
+from __future__ import annotations
+
+import argparse
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import platform
+import statistics
+import subprocess
+import sys
+import time
+from typing import Any
+
+from phase_trace import parse_and_validate_phase_trace
+
+
+class BenchmarkError(RuntimeError):
+    """An incomplete, invalid, or incomparable benchmark run."""
+
+
+@dataclass(frozen=True)
+class Case:
+    name: str
+    series: int = 8
+    samples: int = 10_000
+    data_type: str = "bars"
+    style: str = "line"
+    stacked: bool = False
+    motion: str = "fixed"
+    append: int = 0
+    wrap: bool = False
+    text: bool = True
+    stable_access: bool = True
+
+    def capacity(self, frames: int) -> int:
+        if self.wrap:
+            return self.samples
+        return max(100_000, self.samples + self.append * frames)
+
+    @property
+    def rate(self) -> float:
+        # The renderer normally shows the last ten seconds. Keep denser
+        # workloads visible instead of increasing only offscreen history.
+        return max(1000.0, self.samples / 10.0)
+
+
+CASES = (
+    Case("warm-line-1", series=1),
+    Case("warm-line-8"),
+    Case("warm-line-32", series=32),
+    Case("dense-line-8", samples=100_000),
+    Case("warm-area-8", style="area"),
+    Case("warm-stacked-area-8", style="area", stacked=True),
+    Case("warm-dots-8", data_type="trades", style="dots"),
+    Case("pan-line-8", motion="pan"),
+    Case("zoom-line-8", motion="zoom"),
+    Case("append-line-8", append=16),
+    Case("wrap-line-8", append=16, wrap=True),
+    Case("warm-line-8-no-text", text=False),
+    Case("warm-line-8-conservative", stable_access=False),
+)
+
+METRICS = (
+    "benchmark.frame.total_ms",
+    "benchmark.frame.submission_ms",
+    "benchmark.frame.gpu_finish_ms",
+    "benchmark.frame.cpu_allocation_count",
+    "benchmark.frame.cpu_allocation_bytes",
+)
+PLANNING_METRIC = "benchmark.planning.time_ms"
+AUTO_RANGE_COUNTERS = (
+    "renderer.auto_range.query_count", "renderer.auto_range.range_scan_count",
+)
+
+# Compare the rendering and build environment independently of the workload.
+# Invocation paths, timestamps, checksums of executables, and source revisions
+# intentionally differ between the two variants.
+ENVIRONMENT_KEYS = (
+    "actual_graphics_backend", "device_name", "device_type", "device_id",
+    "vendor_id", "driver_identity", "driver_version", "build_type", "compiler",
+    "qt_version", "os", "kernel_type", "kernel_version", "cpu_architecture",
+    "build_cpu_architecture", "presentation_backend", "framebuffer",
+    "sample_count", "context_sample_count", "context_profile_request",
+    "context_version_request", "fallback_surface_requested_format",
+    "fallback_surface_resolved_format", "env.QT_QPA_PLATFORM",
+    "env.QSG_RHI_BACKEND", "env.GALLIUM_DRIVER", "env.LP_NUM_THREADS",
+    "workload_contract_version", "finish_state", "pixel_readback",
+    "internal_profiling",
+)
+RENDER_ENVIRONMENT = (
+    "QT_QPA_PLATFORM", "QSG_RHI_BACKEND", "QSG_RENDER_LOOP", "QT_SCALE_FACTOR",
+    "QT_SCREEN_SCALE_FACTORS", "QT_FONT_DPI", "LIBGL_ALWAYS_SOFTWARE",
+    "GALLIUM_DRIVER", "LP_NUM_THREADS", "MESA_LOADER_DRIVER_OVERRIDE",
+    "XDG_CACHE_HOME",
+)
+
+
+def write_json(path: Path, value: object) -> None:
+    temporary = path.with_suffix(path.suffix + ".tmp")
+    temporary.write_text(
+        json.dumps(value, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    temporary.replace(path)
+
+
+def finite_number(value: object, name: str) -> float:
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise BenchmarkError(f"{name} is not a number")
+    result = float(value)
+    if not math.isfinite(result):
+        raise BenchmarkError(f"{name} is not finite")
+    return result
+
+
+def observation(payload: dict[str, Any], name: str) -> dict[str, Any]:
+    observations = payload.get("observations")
+    if not isinstance(observations, dict) or name not in observations:
+        raise BenchmarkError(f"required observation is missing: {name}")
+    result = observations[name]
+    if not isinstance(result, dict):
+        raise BenchmarkError(f"observation is not an object: {name}")
+    for key in ("count", "total", "mean", "min", "max"):
+        finite_number(result.get(key), f"{name}.{key}")
+    count = result["count"]
+    if count < 1 or int(count) != count:
+        raise BenchmarkError(f"{name}.count must be a positive integer")
+    if result["min"] < 0 or result["max"] < result["min"]:
+        raise BenchmarkError(f"{name} has invalid nonnegative bounds")
+    if not result["min"] <= result["mean"] <= result["max"]:
+        raise BenchmarkError(f"{name}.mean is outside its bounds")
+    if not math.isclose(result["mean"] * count, result["total"], rel_tol=1e-7, abs_tol=1e-7):
+        raise BenchmarkError(f"{name}.mean and total disagree")
+    return result
+
+
+def total(payload: dict[str, Any], name: str) -> float:
+    return float(observation(payload, name)["total"])
+
+
+def normalized_backend(value: str) -> str:
+    value = "".join(character.lower() for character in value if character.isalnum())
+    return {"opengles2": "opengl", "gles2": "opengl", "gles": "opengl",
+            "direct3d11": "d3d11"}.get(value, value)
+
+
+def expected_metadata(case: Case, args: argparse.Namespace) -> dict[str, str]:
+    return {
+        "workload_contract_version": "2",
+        "data_type": case.data_type.title(),
+        "render_style": case.style.title(),
+        "series_count": str(case.series),
+        "static_sample_count": str(case.samples),
+        "ring_capacity": str(case.capacity(args.frames)),
+        "rate": f"{case.rate:.6f}",
+        "seed": "42",
+        "static_data": "true",
+        "access_semantics": "stable" if case.stable_access else "conservative",
+        "stack_series": str(case.stacked).lower(),
+        "view_motion": case.motion,
+        "append_per_frame": str(case.append),
+        "show_text": str(case.text).lower(),
+        "preview_enabled": "true",
+        "internal_profiling": str(not args.frame_timing_only).lower(),
+        "pixel_readback": "false",
+        "finish_state": "enabled",
+        "presentation_backend": "qrhi-offscreen",
+        "requested_graphics_backend": args.graphics_backend,
+        "measured_frames": str(args.frames),
+        "warmup_frames": str(args.warmup_frames),
+        "scenario": case.name,
+        "framebuffer": "1200x720",
+        "sample_count": "4",
+    }
+
+
+def check_metadata(actual: dict[str, Any], expected: dict[str, Any], context: str) -> None:
+    mismatches = {
+        key: {"expected": value, "actual": actual.get(key)}
+        for key, value in expected.items()
+        if key not in actual or actual[key] != value
+    }
+    if mismatches:
+        raise BenchmarkError(f"{context} metadata mismatch: {json.dumps(mismatches, sort_keys=True)}")
+
+
+def validate_run(
+    payload: dict[str, Any], case: Case, args: argparse.Namespace,
+    command: list[str], directory: Path,
+) -> tuple[dict[str, Any], dict[str, float]]:
+    if payload.get("schema_version") != 1:
+        raise BenchmarkError("unsupported raw report schema")
+    metadata = payload.get("metadata")
+    if not isinstance(metadata, dict):
+        raise BenchmarkError("report metadata is missing")
+    check_metadata(metadata, expected_metadata(case, args), case.name)
+    for key in ENVIRONMENT_KEYS:
+        if key not in metadata or not isinstance(metadata[key], str):
+            raise BenchmarkError(f"required environment metadata is missing: {key}")
+    if payload.get("invocation_args") != command:
+        raise BenchmarkError("raw report invocation does not match the executed command")
+    actual_backend = normalized_backend(metadata["actual_graphics_backend"])
+    if args.graphics_backend == "native":
+        if actual_backend in {"", "null", "uninitialized"}:
+            raise BenchmarkError(f"native graphics request selected {actual_backend}")
+    elif actual_backend != normalized_backend(args.graphics_backend):
+        raise BenchmarkError(f"graphics backend mismatch: {actual_backend}")
+
+    metrics = list(METRICS)
+    if not args.frame_timing_only:
+        metrics.append(PLANNING_METRIC)
+    extracted = {}
+    for name in metrics:
+        values = observation(payload, name)
+        if values["count"] != args.frames:
+            raise BenchmarkError(f"{name}: expected {args.frames} measured frames, got {values['count']}")
+        p95 = finite_number(values.get("p95"), f"{name}.p95")
+        if not values["min"] <= p95 <= values["max"]:
+            raise BenchmarkError(f"{name}.p95 is outside its bounds")
+        if name.endswith("_ms") and values["mean"] <= 0:
+            raise BenchmarkError(f"{name} did not measure positive elapsed work")
+        extracted[name] = {"mean": values["mean"], "p95": p95}
+
+    counters = {}
+    for name in (
+        "benchmark.frame.output_count", "benchmark.ring.published_samples",
+        "benchmark.ring.overwritten_samples", "benchmark.ring.occupancy",
+    ):
+        counters[name] = total(payload, name)
+    if counters["benchmark.frame.output_count"] != args.frames:
+        raise BenchmarkError("completed frame counter mismatch")
+    expected_publications = args.frames * case.append * case.series
+    if counters["benchmark.ring.published_samples"] != expected_publications:
+        raise BenchmarkError("deterministic publication count mismatch")
+    expected_overwrites = expected_publications if case.wrap else 0
+    if counters["benchmark.ring.overwritten_samples"] != expected_overwrites:
+        raise BenchmarkError("ring overwrite count does not match the workload")
+    expected_occupancy = min(case.capacity(args.frames), case.samples + args.frames * case.append)
+    if counters["benchmark.ring.occupancy"] != expected_occupancy * case.series:
+        raise BenchmarkError("final ring occupancy does not match the workload")
+
+    if not args.frame_timing_only:
+        for name in (
+            "renderer.frame.upload.primary_count", "renderer.frame.upload.primary_bytes",
+            "renderer.frame.upload.line_window_count", "renderer.frame.upload.line_window_bytes",
+            "renderer.series_window.monotonicity_scan_count",
+            "renderer.series_window.monotonicity_scan_samples",
+            "renderer.frame.gpu_buffer_allocation_count", "benchmark.snapshot.copied_bytes",
+            *AUTO_RANGE_COUNTERS,
+        ):
+            counters[name] = total(payload, name)
+        if counters["benchmark.snapshot.copied_bytes"] != 0:
+            raise BenchmarkError("the ring snapshot unexpectedly copied sample data")
+        if not case.append and case.motion == "fixed":
+            for name in AUTO_RANGE_COUNTERS:
+                if case.stable_access and counters[name] != 0:
+                    raise BenchmarkError(f"settled stable-access range repeated work: {name}")
+                if not case.stable_access and counters[name] <= 0:
+                    raise BenchmarkError(f"conservative-access control did not exercise range queries: {name}")
+        if case.append:
+            if counters["renderer.frame.upload.primary_count"] <= 0:
+                raise BenchmarkError("append workload did not upload changed sample data")
+        elif case.motion == "fixed" and not case.stacked:
+            for name in (
+                "renderer.frame.upload.primary_count", "renderer.frame.upload.primary_bytes",
+                "renderer.frame.upload.line_window_count", "renderer.frame.upload.line_window_bytes",
+                "renderer.series_window.monotonicity_scan_count",
+                "renderer.series_window.monotonicity_scan_samples",
+                "renderer.frame.gpu_buffer_allocation_count",
+            ):
+                if counters[name] != 0:
+                    raise BenchmarkError(f"settled static frame unexpectedly repeated work: {name}")
+        if case.stacked:
+            for name in ("renderer.stacking.output_sample_count", "renderer.stacking.cache_hit_count"):
+                counters[name] = total(payload, name)
+                if counters[name] <= 0:
+                    raise BenchmarkError(f"static stacked composition was not exercised: {name}")
+
+    trace = Path(metadata.get("phase_trace_path", "")).resolve()
+    if trace.parent != directory.resolve() or not trace.is_file():
+        raise BenchmarkError("phase trace is missing or is outside this run")
+    parse_and_validate_phase_trace(trace.read_text(encoding="utf-8"), args.warmup_frames, args.frames)
+    return extracted, counters
+
+
+def command_for(executable: Path, case: Case, args: argparse.Namespace, directory: Path) -> list[str]:
+    command = [
+        str(executable), "--backend", "qrhi-offscreen", "--graphics-backend", args.graphics_backend,
+        "--static", "--seed", "42", "--data-type", case.data_type, "--render-style", case.style,
+        "--series-count", str(case.series), "--static-samples", str(case.samples),
+        "--ring-size", str(case.capacity(args.frames)), "--rate", str(case.rate),
+        "--view-motion", case.motion, "--append-per-frame", str(case.append),
+        "--warmup-frames", str(args.warmup_frames), "--frames", str(args.frames),
+        "--finish", "--quiet", "--scenario", case.name, "--output-dir", str(directory),
+    ]
+    if case.stacked:
+        command.append("--stack-series")
+    if case.stable_access:
+        command.append("--stable-access")
+    if not case.text:
+        command.append("--no-text")
+    if args.frame_timing_only:
+        command.append("--frame-timing-only")
+    return command
+
+
+def executable_identity(path: Path) -> dict[str, Any]:
+    digest = hashlib.sha256()
+    with path.open("rb") as executable:
+        for chunk in iter(lambda: executable.read(1024 * 1024), b""):
+            digest.update(chunk)
+    result: dict[str, Any] = {"path": str(path), "sha256": digest.hexdigest(), "bytes": path.stat().st_size}
+    try:
+        def git(*arguments: str) -> str:
+            return subprocess.run(
+                ["git", "-C", str(path.parent), *arguments], check=True,
+                capture_output=True, text=True, timeout=10,
+            ).stdout.strip()
+        result["git_at_binary_location"] = {
+            "root": git("rev-parse", "--show-toplevel"),
+            "head": git("rev-parse", "HEAD"),
+            "dirty": bool(git("status", "--porcelain", "--untracked-files=no")),
+            "note": "Repository state at run time; this does not establish the executable's build revision.",
+        }
+    except (OSError, subprocess.SubprocessError):
+        result["git_at_binary_location"] = None
+    return result
+
+
+def host_information() -> dict[str, Any]:
+    result: dict[str, Any] = {
+        "platform": platform.platform(), "python": platform.python_version(),
+        "machine": platform.machine(), "cpu_count": os.cpu_count(),
+        "renderer_environment": {key: os.environ.get(key) for key in RENDER_ENVIRONMENT},
+    }
+    if hasattr(os, "sched_getaffinity"):
+        result["cpu_affinity"] = sorted(os.sched_getaffinity(0))
+    try:
+        cpuinfo = Path("/proc/cpuinfo").read_text(encoding="utf-8")
+        result["cpu_model"] = next(
+            line.split(":", 1)[1].strip() for line in cpuinfo.splitlines() if line.startswith("model name")
+        )
+    except (OSError, StopIteration):
+        result["cpu_model"] = platform.processor() or "unavailable"
+    return result
+
+
+def run_one(
+    executable: Path, variant: str, case: Case, repetition: int,
+    args: argparse.Namespace, output: Path,
+) -> dict[str, Any]:
+    directory = output / case.name / f"{repetition + 1:02d}-{variant}"
+    directory.mkdir(parents=True, exist_ok=False)
+    command = command_for(executable, case, args, directory)
+    invocation: dict[str, Any] = {"command": command, "timeout_seconds": args.timeout_seconds}
+    write_json(directory / "invocation.json", invocation)
+    started = time.monotonic()
+    try:
+        with (directory / "stdout.log").open("w", encoding="utf-8") as stdout:
+            with (directory / "stderr.log").open("w", encoding="utf-8") as stderr:
+                completed = subprocess.run(
+                    command, stdout=stdout, stderr=stderr, text=True,
+                    timeout=args.timeout_seconds, check=False,
+                )
+        invocation["returncode"] = completed.returncode
+        if completed.returncode != 0:
+            raise BenchmarkError(f"{case.name}/{variant} exited {completed.returncode}; see {directory / 'stderr.log'}")
+        reports = list(directory.glob("inspector_benchmark_*.json"))
+        if len(reports) != 1:
+            raise BenchmarkError(f"expected one raw report in {directory}, found {len(reports)}")
+        payload = json.loads(reports[0].read_text(encoding="utf-8"))
+        metrics, counters = validate_run(payload, case, args, command, directory)
+        invocation["status"] = "valid"
+        return {
+            "case": case.name, "variant": variant, "repetition": repetition,
+            "directory": str(directory.relative_to(output)),
+            "raw_report": str(reports[0].relative_to(output)),
+            "metadata": payload["metadata"], "metrics": metrics, "counters": counters,
+            "scopes": payload.get("scopes", {}),
+        }
+    except BaseException as exc:
+        invocation["status"] = "failed"
+        invocation["error"] = str(exc)
+        raise
+    finally:
+        invocation["process_wall_seconds"] = time.monotonic() - started
+        write_json(directory / "invocation.json", invocation)
+
+
+def distribution(values: list[float]) -> dict[str, float | int]:
+    if not values:
+        raise BenchmarkError("cannot summarize an empty set of process replicates")
+    ordered = sorted(values)
+    def quantile(fraction: float) -> float:
+        index = (len(ordered) - 1) * fraction
+        low = int(index)
+        high = min(low + 1, len(ordered) - 1)
+        return ordered[low] + (ordered[high] - ordered[low]) * (index - low)
+    q25, q75 = quantile(0.25), quantile(0.75)
+    return {
+        "n": len(values), "median": statistics.median(values),
+        "q25": q25, "q75": q75, "iqr": q75 - q25,
+        "min": ordered[0], "max": ordered[-1],
+    }
+
+
+def paired_changes(baseline: list[float], candidate: list[float]) -> dict[str, Any]:
+    if len(baseline) != len(candidate) or not baseline:
+        raise BenchmarkError("comparison requires complete paired process replicates")
+    differences = [after - before for before, after in zip(baseline, candidate)]
+    percentages = None
+    if all(before > 0 for before in baseline):
+        percentages = distribution([100.0 * (after / before - 1.0) for before, after in zip(baseline, candidate)])
+    return {"absolute_change": distribution(differences), "percent_change": percentages}
+
+
+def summarize(manifest: dict[str, Any]) -> dict[str, Any]:
+    runs = manifest["runs"]
+    variants = list(manifest["executables"])
+    cases: dict[str, Any] = {}
+    for case in manifest["cases"]:
+        name = case["name"]
+        selected = {
+            variant: sorted(
+                (run for run in runs if run["case"] == name and run["variant"] == variant),
+                key=lambda run: run["repetition"],
+            )
+            for variant in variants
+        }
+        for variant, items in selected.items():
+            if [item["repetition"] for item in items] != list(range(manifest["repetitions"])):
+                raise BenchmarkError(f"incomplete repetition set for {name}/{variant}")
+        metrics = {}
+        metric_names = list(next(iter(selected.values()))[0]["metrics"])
+        for metric in metric_names:
+            item: dict[str, Any] = {}
+            for variant, items in selected.items():
+                item[variant] = {
+                    "run_means": distribution([run["metrics"][metric]["mean"] for run in items]),
+                    "run_p95s": distribution([run["metrics"][metric]["p95"] for run in items]),
+                }
+            if "baseline" in selected:
+                item["paired_means"] = paired_changes(
+                    [run["metrics"][metric]["mean"] for run in selected["baseline"]],
+                    [run["metrics"][metric]["mean"] for run in selected["candidate"]],
+                )
+                item["paired_p95s"] = paired_changes(
+                    [run["metrics"][metric]["p95"] for run in selected["baseline"]],
+                    [run["metrics"][metric]["p95"] for run in selected["candidate"]],
+                )
+            metrics[metric] = item
+        scopes = {}
+        all_names = sorted({scope for items in selected.values() for run in items for scope in run["scopes"]})
+        for scope in all_names:
+            item = {}
+            for variant, items in selected.items():
+                # A removed scope is reported as missing, not invented as zero.
+                available = [run["scopes"][scope] for run in items if scope in run["scopes"]]
+                item[variant] = {"available_runs": len(available)}
+                if available:
+                    times = [finite_number(value["total_ms"], scope) / manifest["frames"] for value in available]
+                    item[variant]["inclusive_ms_per_frame"] = distribution(times)
+            scopes[scope] = item
+        counter_names = sorted({counter for items in selected.values() for run in items for counter in run["counters"]})
+        counters = {
+            counter: {
+                variant: distribution([run["counters"][counter] for run in items])
+                for variant, items in selected.items()
+            }
+            for counter in counter_names
+        }
+        cases[name] = {"metrics": metrics, "counter_totals": counters, "inclusive_scope_costs": scopes}
+    return {
+        "schema_version": 1, "cases": cases,
+        "repetitions": manifest["repetitions"], "frames_per_process": manifest["frames"],
+        "interpretation": {
+            "replicate": "One fresh process. No pooling of frames as independent replicates.",
+            "percent_change": "100 * (candidate / paired baseline - 1); negative means lower cost.",
+            "spread": "IQR and min/max describe process-to-process variation, not a confidence interval.",
+            "frame_total": "Wall time for offscreen frame work, including QRhi completion with --finish; not application FPS or CPU time.",
+            "submission": "Includes begin/endOffscreenFrame and any backend synchronization they perform.",
+            "scope_costs": "Inclusive instrumented CPU-side scope wall times; nested scopes must not be added.",
+            "allocations": "C++ allocations observed on the render thread; excludes profiler storage, malloc-only and other-thread allocations.",
+            "cold": "Setup and cold observations remain in raw reports and are not mixed into warm-frame statistics.",
+            "validation": "Timing runs exclude pixel readback. Validate pixels/semantics separately before accepting an optimization.",
+            "access_semantics": "Stable access identifies immutable benchmark callbacks so production caches can be exercised. The conservative control preserves uncached callback semantics; this workload correction is not a production optimization.",
+        },
+    }
+
+
+def markdown_summary(summary: dict[str, Any], manifest: dict[str, Any]) -> str:
+    paired = "baseline" in manifest["executables"]
+    first = manifest["runs"][0]["metadata"]
+    lines = [
+        "# vnm_plot benchmark suite", "",
+        f"{summary['repetitions']} fresh process replicates per variant and case; "
+        f"{summary['frames_per_process']} measured frames per process after {manifest['warmup_frames']} warmup frames.", "",
+        f"Backend: **{first['actual_graphics_backend']}**, device: **{first['device_name']}**. "
+        f"Qt {first['qt_version']}; {first['compiler']}; {first['build_type']}. "
+        f"Internal profiling: {first['internal_profiling']}. Pixel readback: disabled.", "",
+        "Values below are medians of per-process statistics. A/B order alternates between paired repetitions. "
+        "IQR and min/max describe variation between processes; they are not confidence intervals or automatic pass/fail thresholds.", "",
+        "## Complete offscreen frame wall time", "",
+    ]
+    if paired:
+        lines += [
+            "| Case | Baseline mean ms | Candidate mean ms | Paired change | Paired range | Paired IQR | Baseline p95 ms | Candidate p95 ms |",
+            "|---|---:|---:|---:|---:|---:|---:|---:|",
+        ]
+    else:
+        lines += ["| Case | Mean ms | Run-mean IQR ms | Run-mean range ms | p95 ms |", "|---|---:|---:|---:|---:|"]
+    for name, values in summary["cases"].items():
+        metric = values["metrics"]["benchmark.frame.total_ms"]
+        candidate = metric["candidate"]
+        if paired:
+            baseline = metric["baseline"]
+            change = metric["paired_means"]["percent_change"]
+            lines.append(
+                f"| {name} | {baseline['run_means']['median']:.4f} | {candidate['run_means']['median']:.4f} | "
+                f"{change['median']:+.2f}% | {change['min']:+.2f} to {change['max']:+.2f}% | {change['iqr']:.2f} pp | "
+                f"{baseline['run_p95s']['median']:.4f} | {candidate['run_p95s']['median']:.4f} |"
+            )
+        else:
+            means = candidate["run_means"]
+            lines.append(
+                f"| {name} | {means['median']:.4f} | {means['iqr']:.4f} | "
+                f"{means['min']:.4f} to {means['max']:.4f} | {candidate['run_p95s']['median']:.4f} |"
+            )
+    lines += ["", "## Render-thread C++ allocations per frame", ""]
+    if paired:
+        lines += ["| Case | Baseline count | Candidate count | Baseline bytes | Candidate bytes |", "|---|---:|---:|---:|---:|"]
+    else:
+        lines += ["| Case | Count | Bytes |", "|---|---:|---:|"]
+    for name, values in summary["cases"].items():
+        count = values["metrics"]["benchmark.frame.cpu_allocation_count"]
+        size = values["metrics"]["benchmark.frame.cpu_allocation_bytes"]
+        columns = [name]
+        if paired:
+            columns.append(f"{count['baseline']['run_means']['median']:.2f}")
+        columns.append(f"{count['candidate']['run_means']['median']:.2f}")
+        if paired:
+            columns.append(f"{size['baseline']['run_means']['median']:.2f}")
+        columns.append(f"{size['candidate']['run_means']['median']:.2f}")
+        lines.append("| " + " | ".join(columns) + " |")
+    lines += ["", "## Measurement boundaries", ""]
+    for description in summary["interpretation"].values():
+        lines.append(f"- {description}")
+    lines += [
+        "", "All workload and metadata checks passed. This verifies completion and comparability, "
+        "not rendering correctness or statistical significance. `summary.json` contains paired p95 changes, "
+        "submission/finish/preparation metrics, counter totals, and inclusive scope costs. `manifest.json` links every raw report "
+        "and records executable hashes, host information, and run order. Full stdout/stderr and phase traces are retained per run.", "",
+    ]
+    return "\n".join(lines)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--baseline", type=Path, help="Baseline executable containing the same benchmark harness")
+    parser.add_argument("--candidate", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True, help="New or empty directory; results are never overwritten")
+    parser.add_argument("--graphics-backend", choices=("native", "opengl", "vulkan", "d3d11", "metal", "null"), default="native")
+    parser.add_argument("--repetitions", type=int, default=5)
+    parser.add_argument("--frames", type=int, default=120)
+    parser.add_argument("--warmup-frames", type=int, default=30)
+    parser.add_argument("--timeout-seconds", type=float, default=180)
+    parser.add_argument("--frame-timing-only", action="store_true", help="Disable internal profiling for an outer-timing confirmation run")
+    parser.add_argument("--cases", nargs="+", help="Case names, space or comma separated: " + ", ".join(case.name for case in CASES))
+    args = parser.parse_args()
+    if args.repetitions < 1 or args.frames < 1 or args.warmup_frames < 1:
+        parser.error("repetitions, frames and warmup-frames must be positive")
+    if args.timeout_seconds <= 0 or not math.isfinite(args.timeout_seconds):
+        parser.error("timeout-seconds must be finite and positive")
+    requested = {name for item in args.cases or [] for name in item.split(",")}
+    unknown = requested - {case.name for case in CASES}
+    if unknown:
+        parser.error("unknown cases: " + ", ".join(sorted(unknown)))
+    args.selected_cases = [case for case in CASES if not requested or case.name in requested]
+    for name in ("candidate", "baseline"):
+        executable = getattr(args, name)
+        if executable is not None:
+            executable = executable.resolve()
+            if not executable.is_file():
+                parser.error(f"{name} executable does not exist: {executable}")
+            setattr(args, name, executable)
+    args.output_dir = args.output_dir.resolve()
+    if args.output_dir.exists() and (not args.output_dir.is_dir() or any(args.output_dir.iterdir())):
+        parser.error("output-dir must be new or empty; choose another directory to preserve existing results")
+    return args
+
+
+def main() -> int:
+    args = parse_args()
+    output = args.output_dir
+    output.mkdir(parents=True, exist_ok=True)
+    executables = {"candidate": args.candidate}
+    if args.baseline:
+        executables = {"baseline": args.baseline, "candidate": args.candidate}
+    manifest: dict[str, Any] = {
+        "schema_version": 1, "status": "running", "created_at": datetime.now(timezone.utc).isoformat(),
+        "host": host_information(),
+        "executables": {variant: executable_identity(path) for variant, path in executables.items()},
+        "cases": [asdict(case) for case in args.selected_cases], "repetitions": args.repetitions,
+        "frames": args.frames, "warmup_frames": args.warmup_frames,
+        "graphics_backend": args.graphics_backend, "internal_profiling": not args.frame_timing_only,
+        "run_order": [], "runs": [],
+    }
+    manifest_path = output / "manifest.json"
+    write_json(manifest_path, manifest)
+    reference_environment = None
+    try:
+        for repetition in range(args.repetitions):
+            order = list(executables)
+            if repetition % 2:
+                order.reverse()
+            for case in args.selected_cases:
+                for variant in order:
+                    print(f"[{repetition + 1}/{args.repetitions}] {case.name}: {variant}", flush=True)
+                    manifest["run_order"].append({"case": case.name, "repetition": repetition, "variant": variant})
+                    write_json(manifest_path, manifest)
+                    result = run_one(executables[variant], variant, case, repetition, args, output)
+                    environment = {key: result["metadata"][key] for key in ENVIRONMENT_KEYS}
+                    if reference_environment is None:
+                        reference_environment = environment
+                    else:
+                        check_metadata(environment, reference_environment, "build/renderer comparability")
+                    manifest["runs"].append(result)
+                    write_json(manifest_path, manifest)
+        summary = summarize(manifest)
+        write_json(output / "summary.json", summary)
+        (output / "summary.md").write_text(markdown_summary(summary, manifest), encoding="utf-8")
+        manifest["status"] = "complete"
+    except BaseException as exc:
+        manifest["status"] = "interrupted" if isinstance(exc, KeyboardInterrupt) else "failed"
+        manifest["error"] = str(exc)
+        raise
+    finally:
+        manifest["ended_at"] = datetime.now(timezone.utc).isoformat()
+        write_json(manifest_path, manifest)
+    print(output / "summary.md")
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except KeyboardInterrupt:
+        print("benchmark suite interrupted; completed run artifacts were retained", file=sys.stderr)
+        raise SystemExit(130)
+    except (BenchmarkError, OSError, subprocess.SubprocessError, ValueError, KeyError) as exc:
+        print(f"benchmark suite failed: {exc}", file=sys.stderr)
+        raise SystemExit(1) from exc
diff --git a/benchmark/tools/test_phase_trace_flush.py b/benchmark/tools/test_phase_trace_flush.py
index 246588d5..824aab1a 100644
--- a/benchmark/tools/test_phase_trace_flush.py
+++ b/benchmark/tools/test_phase_trace_flush.py
@@ -13,6 +13,9 @@
 def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--executable", type=Path, required=True)
+    # This checks durable phase output and termination, not rasterization.
+    # Native rendering remains covered by validate_smoke.py.
+    parser.add_argument("--graphics-backend", default="null")
     return parser.parse_args()
 
 
@@ -26,7 +29,7 @@ def main() -> int:
                 "--backend",
                 "qrhi-offscreen",
                 "--graphics-backend",
-                "native",
+                args.graphics_backend,
                 "--static",
                 "--data-type",
                 "bars",
diff --git a/benchmark/tools/test_run_suite.py b/benchmark/tools/test_run_suite.py
new file mode 100644
index 00000000..27bde954
--- /dev/null
+++ b/benchmark/tools/test_run_suite.py
@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""Reject invalid benchmark evidence before calculating a speedup."""
+
+from __future__ import annotations
+
+from argparse import Namespace
+import copy
+from dataclasses import replace
+import json
+from pathlib import Path
+import tempfile
+import unittest
+
+import run_suite as suite
+from phase_trace import expected_phases
+
+
+def constant_observation(value: float, count: int = 1) -> dict:
+    return {"count": count, "total": value * count, "mean": value,
+            "min": value, "max": value, "p95": value}
+
+
+class EvidenceValidation(unittest.TestCase):
+    def setUp(self) -> None:
+        self.temporary = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temporary.cleanup)
+        self.directory = Path(self.temporary.name)
+        self.case = suite.Case("warm-line-1", series=1)
+        self.args = Namespace(frames=3, warmup_frames=2, graphics_backend="opengl", frame_timing_only=True)
+        metadata = {name: "fixture" for name in suite.ENVIRONMENT_KEYS}
+        metadata.update(suite.expected_metadata(self.case, self.args))
+        metadata["actual_graphics_backend"] = "OpenGLES2"
+        trace = self.directory / "trace.jsonl"
+        trace.write_text("\n".join(
+            json.dumps({"phase": phase, "frame": frame, "elapsed_ms": index})
+            for index, (phase, frame) in enumerate(expected_phases(2, 3))
+        ), encoding="utf-8")
+        metadata["phase_trace_path"] = str(trace)
+        observations = {name: constant_observation(2, 3) for name in suite.METRICS}
+        observations.update({
+            "benchmark.frame.output_count": constant_observation(1, 3),
+            "benchmark.ring.published_samples": constant_observation(0),
+            "benchmark.ring.overwritten_samples": constant_observation(0),
+            "benchmark.ring.occupancy": constant_observation(10_000),
+        })
+        self.payload = {"schema_version": 1, "metadata": metadata,
+                        "invocation_args": ["benchmark"], "observations": observations}
+
+    def validate(self, payload: dict | None = None) -> None:
+        suite.validate_run(payload or self.payload, self.case, self.args, ["benchmark"], self.directory)
+
+    def test_timing_only_still_requires_exact_work_and_complete_frames(self) -> None:
+        self.validate()  # No internal scopes or planning metric are required.
+        for name, replacement in (
+            ("benchmark.frame.total_ms", constant_observation(2, 2)),
+            ("benchmark.ring.published_samples", constant_observation(1)),
+            ("benchmark.ring.occupancy", constant_observation(0)),
+        ):
+            with self.subTest(name=name):
+                payload = copy.deepcopy(self.payload)
+                payload["observations"][name] = replacement
+                with self.assertRaises(suite.BenchmarkError):
+                    self.validate(payload)
+
+    def test_missing_counter_is_not_zero(self) -> None:
+        del self.payload["observations"]["benchmark.ring.published_samples"]
+        with self.assertRaisesRegex(suite.BenchmarkError, "required observation is missing"):
+            self.validate()
+
+    def test_old_contract_wrong_backend_and_readback_are_rejected(self) -> None:
+        for key, value in (("workload_contract_version", "1"),
+                           ("actual_graphics_backend", "Null"), ("pixel_readback", "true"),
+                           ("access_semantics", "conservative")):
+            with self.subTest(key=key):
+                payload = copy.deepcopy(self.payload)
+                payload["metadata"][key] = value
+                with self.assertRaises(suite.BenchmarkError):
+                    self.validate(payload)
+
+    def test_nonfinite_and_inconsistent_statistics_are_rejected(self) -> None:
+        for key, value in (("mean", float("nan")), ("total", 999), ("p95", 999), ("count", True)):
+            with self.subTest(key=key):
+                payload = copy.deepcopy(self.payload)
+                payload["observations"]["benchmark.frame.total_ms"][key] = value
+                with self.assertRaises(suite.BenchmarkError):
+                    self.validate(payload)
+
+    def test_profiling_enabled_requires_internal_counters(self) -> None:
+        self.args.frame_timing_only = False
+        self.payload["metadata"]["internal_profiling"] = "true"
+        self.payload["observations"][suite.PLANNING_METRIC] = constant_observation(1, 3)
+        with self.assertRaisesRegex(suite.BenchmarkError, "renderer.frame.upload.primary_count"):
+            self.validate()
+
+    def test_stable_range_cache_and_conservative_control_are_distinguished(self) -> None:
+        self.args.frame_timing_only = False
+        self.payload["metadata"]["internal_profiling"] = "true"
+        observations = self.payload["observations"]
+        observations[suite.PLANNING_METRIC] = constant_observation(1, 3)
+        for name in (
+            "renderer.frame.upload.primary_count", "renderer.frame.upload.primary_bytes",
+            "renderer.frame.upload.line_window_count", "renderer.frame.upload.line_window_bytes",
+            "renderer.series_window.monotonicity_scan_count",
+            "renderer.series_window.monotonicity_scan_samples",
+            "renderer.frame.gpu_buffer_allocation_count", "benchmark.snapshot.copied_bytes",
+            *suite.AUTO_RANGE_COUNTERS,
+        ):
+            observations[name] = constant_observation(0)
+        self.validate()
+        observations["renderer.auto_range.query_count"] = constant_observation(2, 3)
+        with self.assertRaisesRegex(suite.BenchmarkError, "settled stable-access range"):
+            self.validate()
+        self.case = replace(self.case, stable_access=False)
+        self.payload["metadata"]["access_semantics"] = "conservative"
+        with self.assertRaisesRegex(suite.BenchmarkError, "conservative-access control"):
+            self.validate()
+        observations["renderer.auto_range.range_scan_count"] = constant_observation(2, 3)
+        self.validate()
+
+
+class ComparisonValidation(unittest.TestCase):
+    def test_pairing_is_preserved_instead_of_ratio_of_pooled_medians(self) -> None:
+        comparison = suite.paired_changes([1.0, 100.0, 100.0], [2.0, 50.0, 100.0])
+        # Paired changes are +100%, -50%, 0%. A ratio of medians says -50%.
+        self.assertEqual(comparison["percent_change"]["median"], 0.0)
+        self.assertEqual(comparison["percent_change"]["n"], 3)
+        with self.assertRaises(suite.BenchmarkError):
+            suite.paired_changes([1.0, 2.0], [1.0])
+
+    def test_zero_baseline_has_absolute_change_without_invented_percentage(self) -> None:
+        comparison = suite.paired_changes([0.0, 0.0], [1.0, 2.0])
+        self.assertIsNone(comparison["percent_change"])
+        self.assertEqual(comparison["absolute_change"]["median"], 1.5)
+
+    def test_incomparable_environment_is_rejected(self) -> None:
+        expected = {"device_name": "hardware GPU", "compiler": "GNU 13", "internal_profiling": "true"}
+        for key, replacement in (("device_name", "llvmpipe"), ("compiler", "GNU 14"),
+                                 ("internal_profiling", "false")):
+            with self.subTest(key=key):
+                changed = dict(expected, **{key: replacement})
+                with self.assertRaises(suite.BenchmarkError):
+                    suite.check_metadata(changed, expected, "comparison")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/benchmark/tools/validate_workloads.py b/benchmark/tools/validate_workloads.py
new file mode 100644
index 00000000..9d48c171
--- /dev/null
+++ b/benchmark/tools/validate_workloads.py
@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Exercise benchmark workload/measurement contracts, without timing thresholds."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+
+
+def run(executable: Path, output: Path, *extra: str) -> dict:
+    command = [
+        str(executable.resolve()), "--backend", "qrhi-offscreen",
+        "--graphics-backend", "null", "--static", "--stable-access", "--seed", "42",
+        "--static-samples", "1024", "--ring-size", "1024",
+        "--series-count", "2", "--render-style", "line",
+        "--warmup-frames", "4", "--frames", "8", "--finish", "--quiet",
+        "--output-dir", str(output), *extra,
+    ]
+    environment = dict(os.environ, QT_QPA_PLATFORM="offscreen")
+    result = subprocess.run(command, capture_output=True, text=True,
+                            timeout=45, env=environment)
+    if result.returncode:
+        raise RuntimeError(f"{command!r}\n{result.stdout}\n{result.stderr}")
+    reports = list(output.glob("inspector_benchmark_*.json"))
+    if len(reports) != 1:
+        raise RuntimeError("Expected one raw report per run")
+    report = json.loads(reports[0].read_text(encoding="utf-8"))
+    observations = report["observations"]
+    assert report["metadata"]["workload_contract_version"] == "2"
+    assert observations["benchmark.frame.output_count"]["total"] == 8
+    assert observations["benchmark.frame.total_ms"]["count"] == 8
+    assert observations["benchmark.frame.cpu_allocation_count"]["count"] == 8
+    return report
+
+
+def total(report: dict, metric: str) -> float:
+    return report["observations"][metric]["total"]
+
+
+def view_spans(report: dict) -> list[float]:
+    observations = report["observations"]
+    return [last - first for first, last in zip(
+        observations["benchmark.view.t_min_ns"]["samples"],
+        observations["benchmark.view.t_max_ns"]["samples"], strict=True)]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--executable", required=True, type=Path)
+    args = parser.parse_args()
+    with tempfile.TemporaryDirectory(prefix="vnm_plot_workloads_") as directory:
+        root = Path(directory)
+        fixed = run(args.executable, root / "fixed")
+        # A settled plot consumes measured axis-width feedback, as Plot_widget
+        # does. Reusing the initial 60px width must not force layout misses.
+        assert "renderer.frame.calculate_layout.impl.cache_miss.pass1" not in fixed["scopes"]
+        assert total(fixed, "renderer.frame.upload.primary_count") == 0
+        assert total(fixed, "renderer.frame.upload.line_window_count") == 0
+        assert total(fixed, "benchmark.ring.published_samples") == 0
+        assert total(fixed, "renderer.auto_range.query_count") == 0
+        assert total(fixed, "renderer.auto_range.range_scan_count") == 0
+
+        pan = run(args.executable, root / "pan", "--view-motion", "pan")
+        positions = pan["observations"]["benchmark.view.t_min_ns"]["samples"]
+        assert all(a < b for a, b in zip(positions, positions[1:]))
+        assert max(view_spans(pan)) - min(view_spans(pan)) <= 1
+        assert total(pan, "benchmark.ring.published_samples") == 0
+
+        zoom = run(args.executable, root / "zoom", "--view-motion", "zoom")
+        spans = view_spans(zoom)
+        assert all(a < b for a, b in zip(spans, spans[1:]))
+
+        append = run(args.executable, root / "append", "--append-per-frame", "32")
+        assert total(append, "benchmark.ring.published_samples") == 8 * 32 * 2
+        assert total(append, "benchmark.ring.overwritten_samples") == 8 * 32 * 2
+        assert total(append, "renderer.frame.upload.primary_count") > 0
+        assert append["observations"]["benchmark.workload.publish_ms"]["count"] == 8
+
+        outer = run(args.executable, root / "outer", "--frame-timing-only", "--no-preview")
+        assert outer["metadata"]["internal_profiling"] == "false"
+        assert outer["metadata"]["preview_enabled"] == "false"
+        assert "renderer.frame" not in outer["scopes"]
+        assert "renderer.frame.upload.primary_count" not in outer["observations"]
+        assert not any(name.startswith("renderer.") for name in outer["observations"])
+        assert "benchmark.planning.time_ms" not in outer["observations"]
+        assert total(outer, "benchmark.ring.published_samples") == 0
+
+        for invalid in (["--view-motion", "unknown"],
+                        ["--view-motion", "pan", "--append-per-frame", "1"],
+                        ["--append-per-frame", "1"],
+                        ["--view-motion", "zoom", "--static"]):
+            result = subprocess.run([str(args.executable.resolve()), *invalid],
+                                    capture_output=True, text=True, timeout=10)
+            assert result.returncode == 1, (invalid, result.returncode, result.stderr)
+    print("Benchmark fixed/pan/zoom/publication, feedback, and timing-only contracts passed")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/test_core_algo.cpp b/tests/test_core_algo.cpp
index 496faa40..a31703f7 100644
--- a/tests/test_core_algo.cpp
+++ b/tests/test_core_algo.cpp
@@ -1198,6 +1198,79 @@ bool test_label_fades_start_at_threshold_and_finish_after_zoom_stops()
     return true;
 }
 
+template<typename Key>
+bool check_label_membership_changes(Key first, Key second)
+{
+    struct label_t
+    {
+        Key         value;
+        std::string text;
+    };
+
+    using clock_t = std::chrono::steady_clock;
+    plot::Text_renderer::axis_fade_tracker_t<Key> tracker;
+    std::vector<label_t> labels{{second, "two"}, {first, "one"}, {second, "two"}};
+    std::map<Key, float> drawn;
+    auto now = clock_t::time_point{} + std::chrono::seconds(1);
+    const auto update = [&](bool animate_changes) {
+        drawn.clear();
+        return plot::detail::update_and_draw_faded_labels(
+            labels,
+            tracker,
+            180.0f,
+            animate_changes,
+            now,
+            [](const label_t& label) { return label.value; },
+            [&](Key key, const std::string&, float alpha) { drawn[key] += alpha; });
+    };
+    const std::map<Key, float> opaque{{first, 1.0f}, {second, 1.0f}};
+    const std::map<Key, float> halfway{{first, 0.5f}, {second, 0.5f}};
+
+    TEST_ASSERT(!update(false) && drawn == opaque && tracker.visible_alphas == opaque,
+        "unordered duplicate keys should initially emit each label once");
+    labels = {{first, "one"}, {second, "two"}, {first, "one"}};
+    now += std::chrono::milliseconds(90);
+    TEST_ASSERT(!update(false) && drawn == opaque && tracker.states.size() == 2,
+        "reordering and duplicating current keys should preserve settled labels");
+
+    labels.clear();
+    TEST_ASSERT(!update(false) && drawn.empty() && tracker.states.empty()
+        && tracker.visible_alphas.empty(),
+        "an empty nonanimated layout should remove every label and grid extension");
+    labels = {{second, "two"}, {first, "one"}, {second, "two"}};
+    TEST_ASSERT(!update(false) && drawn == opaque && tracker.visible_alphas == opaque,
+        "repopulating an empty layout should restore each current label once");
+
+    labels.clear();
+    TEST_ASSERT(update(true) && drawn == opaque && tracker.visible_alphas == opaque,
+        "an empty animated layout should retain outgoing labels on the transition frame");
+    now += std::chrono::milliseconds(90);
+    TEST_ASSERT(update(true) && drawn == halfway && tracker.visible_alphas == halfway,
+        "absent labels and grid extensions should fade together while the layout stays empty");
+
+    labels = {{second, "two"}, {second, "two"}};
+    TEST_ASSERT(update(true) && drawn == halfway && tracker.visible_alphas == halfway,
+        "a repeated returning key should reverse its fade without doubling its opacity");
+    now += std::chrono::milliseconds(90);
+    const std::map<Key, float> returned{{second, 1.0f}};
+    TEST_ASSERT(!update(false) && drawn == returned && tracker.visible_alphas == returned
+        && tracker.states.size() == 1 && tracker.states.count(first) == 0,
+        "only the returning label should survive after the other outgoing fade completes");
+
+    labels = {{first, "one"}};
+    const std::map<Key, float> replaced{{first, 1.0f}};
+    TEST_ASSERT(!update(false) && drawn == replaced && tracker.visible_alphas == replaced
+        && tracker.states.size() == 1 && tracker.states.count(second) == 0,
+        "a subsequent replacement should not retain keys from an earlier layout");
+    return true;
+}
+
+bool test_label_membership_handles_reordering_empty_layouts_and_reappearance()
+{
+    return check_label_membership_changes(0.25, 0.75)
+        && check_label_membership_changes<std::int64_t>(1, 3);
+}
+
 bool test_lcd_policy_helpers()
 {
     using request_t  = plot::lcd_request_t;
@@ -1579,6 +1652,7 @@ int main()
     RUN_TEST(test_timestamp_positions_preserve_epoch_nanoseconds);
     RUN_TEST(test_horizontal_label_fade_keys_preserve_int64_timestamps);
     RUN_TEST(test_label_fades_start_at_threshold_and_finish_after_zoom_stops);
+    RUN_TEST(test_label_membership_handles_reordering_empty_layouts_and_reappearance);
     RUN_TEST(test_lcd_policy_helpers);
     RUN_TEST(test_built_in_label_backgrounds_are_opaque_for_lcd);
     RUN_TEST(test_grid_lcd_order_selection);

From a15293f39b52bbee54e129d59e6739e74a2970e6 Mon Sep 17 00:00:00 2001
From: Ioannis Makris <imak@imak.gr>
Date: Wed, 4 Nov 2026 02:06:02 +0100
Subject: [PATCH 2/5] Document benchmark evidence and retain conservative
 timing controls

Recover the final 14-case suite, report and compact measurements without applying the experimental production optimization.

Source tree is byte-identical to original foundation head 15eb736a897d147afa799470318312d913f06f13. Retained Linux QRhi Null measurements establish CPU preparation-path cost and allocation traffic only; the separately retained production experiment has an unresolved conservative-workload slowdown.

Original history remains in vnm_plot-benchmarks-2026-11-04.zip.
---
 benchmark/README.md                           |    7 +-
 benchmark/results/2026-11-04-null/README.md   |  217 +
 .../results/2026-11-04-null/measurements.json | 5594 +++++++++++++++++
 benchmark/tools/run_suite.py                  |    6 +
 4 files changed, 5823 insertions(+), 1 deletion(-)
 create mode 100644 benchmark/results/2026-11-04-null/README.md
 create mode 100644 benchmark/results/2026-11-04-null/measurements.json

diff --git a/benchmark/README.md b/benchmark/README.md
index 30c9b135..b5d3296a 100644
--- a/benchmark/README.md
+++ b/benchmark/README.md
@@ -1,5 +1,9 @@
 # vnm_plot benchmark
 
+For an initial measured baseline and a small allocation experiment, see the
+[2026-11-04 results](results/2026-11-04-null/README.md), including the unresolved
+conservative-access timing regression and the limits of the Null backend.
+
 `vnm_plot_benchmark` measures the complete vnm_plot render path with synthetic
 Bars or Trades data. It supports multiple independent series, static data, and
 live publication through ring buffers.
@@ -80,6 +84,7 @@ The suite runs these named cases, selectable with `--cases NAME ...`:
 | `wrap-line-8` | The same publication schedule into a full ring, including split spans |
 | `warm-line-8-no-text` | Control for text/layout changes |
 | `warm-line-8-conservative` | Callbacks without a declared stable semantic identity |
+| `warm-line-8-conservative-no-text` | Range-scan control without the text path |
 
 Ordinary cases contain 10,000 samples per series. The seed, dimensions, series
 count, rates, data/style, warmup and measured frames are explicit in every
@@ -88,7 +93,7 @@ history within the ten-second view instead of only increasing invisible data.
 Preview rendering is enabled in the suite; individual runs can use
 `--no-preview` to isolate the main pane.
 
-The suite passes `--stable-access` except in the conservative control. The
+The suite passes `--stable-access` except in the conservative controls. The
 benchmark's stateless callbacks then declare their actual immutable semantics
 through the public policy API, allowing production range-cache reuse. A
 byte-layout key alone does not establish callback semantics. This is a
diff --git a/benchmark/results/2026-11-04-null/README.md b/benchmark/results/2026-11-04-null/README.md
new file mode 100644
index 00000000..93870a7c
--- /dev/null
+++ b/benchmark/results/2026-11-04-null/README.md
@@ -0,0 +1,217 @@
+# vnm_plot: benchmark foundation and allocation experiment
+
+**Date:** 2026-11-04
+
+**Status:** benchmark infrastructure implemented and exercised; production change retained as a separate experiment.
+
+**Scope:** QRhi Null/offscreen on Linux. No raster or GPU performance claim.
+
+## Result and recommendation
+
+The primary deliverable is a repeatable suite of **14 named workloads**, with explicit input schedules, workload validation, paired process comparisons, machine-readable evidence, and documented measurement boundaries. It extends the existing production-frame benchmark rather than introducing an unrelated synthetic renderer.
+
+A small label-processing change demonstrates that the suite can identify and verify useful work: an ordinary settled eight-series LINE or AREA frame falls from **190 to 152 render-thread C++ allocations** and from **13,952 to 13,056 requested allocation bytes**. That is **38 fewer allocations (20%) and 896 fewer requested bytes per frame**. The corresponding text-disabled control stays at **114 allocations and 9,312 bytes** in both binaries.
+
+Timing is less conclusive. Longer, reduced-instrumentation runs show median paired mean-time reductions of **3.75%–7.18%** across the selected settled text workloads, but process variation is substantial and tail results are mixed. A range-scan-heavy conservative-access workload is slower, including when text is disabled. The benchmark foundation is useful now; the production change should remain an **experimental, separately reviewable commit**, pending investigation of that timing regression and validation on a raster backend. Allocation savings alone do not establish that the candidate is generally faster.
+
+The evidence consists of **284 fresh processes and 675,200 measured frames** across three completed experiments. Statistical replicates are the paired processes, not the individual frames. The full archive retains every final raw JSON/text report, invocation, stdout/stderr log, phase trace, manifest, build provenance, and validation log. Compact results are in [measurements.json](measurements.json); operational instructions are in [the benchmark README](../../README.md).
+
+## Workload coverage
+
+Ordinary cases use 10,000 samples per series, a fixed seed of 42, a 1200 × 720 framebuffer, 4× MSAA request, preview enabled, explicit line/dot widths, and QRhi completion enabled. Timing runs disable pixel readback. Sources expose LOD 0.
+
+| Cases | Purpose and controlled work |
+|---|---|
+| `warm-line-1`, `warm-line-8`, `warm-line-32` | Settled per-frame cost as series count grows |
+| `dense-line-8` | 100,000 samples per series, all within the visible ten-second range; checks warm reuse with a denser uploaded dataset |
+| `warm-area-8`, `warm-dots-8` | AREA and DOTS preparation/submission paths |
+| `warm-stacked-area-8` | Stack composition and reuse |
+| `pan-line-8` | A quarter-width view moving across fixed history on a 120-frame triangular cycle |
+| `zoom-line-8` | Centered view changing from 10% to 100% of the available history on the same cycle |
+| `append-line-8` | Exactly 16 new samples per series before each measured frame, with no ring overwrite |
+| `wrap-line-8` | The same publication schedule into a full 10,000-sample ring, exercising overwrite and split spans |
+| `warm-line-8-no-text` | Stable-access control without the text path |
+| `warm-line-8-conservative` | Immutable fixture callbacks deliberately left without a stable semantic identity, forcing range queries/scans |
+| `warm-line-8-conservative-no-text` | Matched range-scan control without the text path |
+
+The dense settled case measures reuse after warmup, not rebuilding or uploading 100,000 samples on every frame. The appended data is generated synchronously before the render timer; its cost is separately reported as `benchmark.workload.publish_ms`. This separates rendering cost from producer scheduling. It does not measure producer-thread contention.
+
+Input schedules are deterministic. Label fades still use elapsed real time, so moving/updating cases can retain different outgoing labels at different execution speeds. Those cases are not guaranteed pixel-identical frame sequences. Settled cases provide stronger timing controls, while fixed-clock algorithm tests cover fade behavior.
+
+## Changes that make the measurements meaningful
+
+1. **Match production layout feedback.** The offscreen runner now consumes `measured_vbar_width`, as the shipping widget does. Previously it kept its initial width, causing a layout miss on every otherwise static frame. An actual-renderer contract test checks that settled layout work is reused.
+2. **Separate stable and conservative data access.** The fixture's stateless callbacks can now declare their real immutable semantics with `--stable-access`. A byte-layout key alone was insufficient, so the original fixture repeatedly scanned ranges even for unchanged data. Stable-access cases exercise production caching; conservative controls preserve the uncached contract. This is a benchmark-workload correction, not a claimed production optimization. Both compared binaries contain it.
+3. **Specify work by frame count.** Publication, pan, and zoom advance by measured-frame index rather than wall-clock producer timing. Warmup does not consume the measured input sequence. Ring occupancy, publications, and overwrites must match exact expected totals.
+4. **Reject incomparable runs.** The runner checks exit status, phase completion, exact frame counts, required metrics, finite/internally consistent observations, the executed command, workload metadata, renderer identity, build configuration, and backend selection. It rejects unexpected static scans/uploads and missing evidence. Null is accepted only when explicitly requested.
+5. **Preserve pairing and variation.** Each variant runs in a fresh process. A/B order alternates with B/A between repetitions. Results include per-process means/p95s, paired changes, IQR and min/max; frame samples are not pooled as independent experiments. No machine-specific timing threshold is installed in CTest.
+6. **Distinguish diagnostic and reduced-instrumentation runs.** Normal runs collect internal scopes and work counters. `--frame-timing-only` disables production renderer/source profiling while retaining outer timings, allocation hooks, and exact publication accounting. Unavailable internal counters remain absent rather than being reported as zero.
+
+## Measurement boundaries
+
+| Metric | Interpretation |
+|---|---|
+| `benchmark.frame.total_ms` | Wall time of the timed offscreen frame path, including QRhi begin/end calls, production planning/layout/text/series preparation, submission, and `--finish`; excludes setup and synchronous input generation |
+| `benchmark.frame.submission_ms` | Work through end-of-frame; QRhi calls may synchronize, so this is not pure CPU submission time |
+| `benchmark.frame.gpu_finish_ms` | Wall time of the extra finish call, not a hardware GPU timer |
+| C++ allocation count/bytes | Render-thread allocation requests inside the measured scope, excluding profiler storage; not all `malloc` calls, other threads, GPU memory, retained memory, or peak memory |
+| Upload/scan counters | Amount of renderer work requested; useful for explaining repeated work and validating equivalent workloads, even on Null |
+| Internal scopes | Inclusive CPU-side wall times, aggregated by full scope name; parent/child times must not be summed |
+| Setup/warmup observations | Preserved separately from measured frames; existing font/disk caches were not controlled for a cold-start study |
+
+QRhi Null executes the production CPU preparation path and submission bookkeeping without rasterization. It cannot establish GPU throughput, application FPS, native presentation latency, or rendered-pixel equivalence. The suite also does not cover LOD switching, custom layers, the Qt Quick event/synchronization loop, or complete Logonomic integration.
+
+## Experimental setup
+
+| Experiment | Cases | Pairs per case | Measured frames/process | Warmup/process | Internal profiling | Processes |
+|---|---:|---:|---:|---:|---|---:|
+| `final-paired-outer` | 7 settled/control | 9 | 5,000 | 100 | Disabled | 126 |
+| `final-paired-diagnostic` | 13 original suite cases | 5 | 240 | 30 | Enabled | 130 |
+| `final-conservative-controls` | 2 conservative controls | 7 | 500 | 30 | Disabled | 28 |
+
+All runs used the same two retained binaries, pinned to logical CPU 8, on an AMD EPYC 9V74 Linux host. OS: Ubuntu 24.04.3, kernel 6.18.57, glibc 2.39. Build: Release, GCC/G++ 13.3.0, `-O3 -DNDEBUG`, Qt 6.12.0, CMake 3.31.10, Ninja 1.13.2, ccache 4.9.1. Actual FreeType: **2.13.2 from the SDK**. A prepared 2.14.3 checkout was not selected by CMake. `QT_QPA_PLATFORM=offscreen`; actual QRhi backend/device: Null.
+
+| Input | Exact revision or SHA-256 |
+|---|---|
+| Original repository base | `727eb9d085a37524c3a6ae67e16ba6a4def5d6dd` |
+| Compiled benchmark baseline | `88d459dbbad9cff1a292b3ffa87be97970d371e6` |
+| Compiled production candidate | `70638b6e65103b657daaa16e00bcea7fe8daf800` |
+| Final Python suite and workload documentation | `5b40d72ed32b04c52bab15372acccd060c650dc9` |
+| Baseline executable SHA-256 | `a421c9d8832519110d6bc0eb2253916798eef0d30512f5359f46673c51f29f5d` |
+| Candidate executable SHA-256 | `77cfcf554e536ae0adfb4575ae8e7cf89623aa13fa99003e7df5088b96b21c9d` |
+| SDK archive SHA-256 | `56100ede7b00bd7faf06a7b64c57b94106f63e3ba1b77c0bbdf5d61d7ca220c2` |
+| vnm_msdf_text | `3e89f1358c88b46f7c68b99dd9bf76003b5a3db3` |
+| vnm_fonts | `c9adbd52cd3bc983d313993436381522e15864e1` |
+| vnm_cmake | `66d5ee14f4f69c952daa58a95a4759ad77a636f4` |
+| glm 1.0.3 | `8d1fd52e5ab5590e2c81768ace50c72bae28f2ed` |
+| msdfgen 1.13 | `1874bcf7d9624ccc85b4bc9a85d78116f690f35b` |
+
+The C++ benchmark harness is identical in the two compiled variants; only the label-membership production change differs. The same Python runner/explicit parameter values were used for each pair. The final runner commit also adds the second conservative control; that control was measured in its focused experiment, not retrospectively inserted into the original 13-case matrix. Executable hashes establish which binaries ran; an enclosing checkout's revision at run time alone would not establish their build provenance.
+
+## Small production experiment
+
+The existing fade tracker built a temporary `unordered_set` of current label keys on each update. The candidate reuses the retained per-label state: reset a membership flag during the existing state pass, mark each current label, and consult the flag when retiring absent labels. It removes temporary hash-set allocations without changing the intended fade progression or key ordering.
+
+The production change is confined to `src/core/label_fade_tracker.h` and one field in `include/vnm_plot/rhi/text_renderer.h`: eight inserted lines and five removed lines. It is commit `70638b6`, separate from the benchmark commits. Behavior tests cover duplicate/unordered keys, reordering, empty layouts, immediate repopulation, animated disappearance, return during a fade, fade reversal, old-key expiry and replacement, for both fractional `double` and `int64_t` keys. The tests check emitted/grid alpha and retained keys rather than the new flag.
+
+### Allocation results
+
+These settled-workload counts are exact and unchanged across the repetitions of the reported experiments. They are allocation traffic, not retained memory savings.
+
+| Case | Baseline allocations/frame | Candidate allocations/frame | Baseline requested bytes/frame | Candidate requested bytes/frame |
+|---|---:|---:|---:|---:|
+| `warm-line-1` | 99 | 61 | 7,400 | 6,504 |
+| `warm-line-8` | 190 | 152 | 13,952 | 13,056 |
+| `warm-line-32` | 502 | 464 | 36,416 | 35,520 |
+| `dense-line-8` | 190 | 152 | 13,952 | 13,056 |
+| `warm-area-8` | 190 | 152 | 13,952 | 13,056 |
+| `warm-dots-8` | 186 | 142 | 14,464 | 13,424 |
+| `warm-line-8-no-text` | 114 | 114 | 9,312 | 9,312 |
+| `warm-stacked-area-8` | 246 | 204 | 24,128 | 23,152 |
+| `warm-line-8-conservative` | 206 | 168 | 14,464 | 13,568 |
+| `warm-line-8-conservative-no-text` | 130 | 130 | 9,824 | 9,824 |
+
+In these fixtures, the ordinary LINE/AREA allocation reduction is independent of the series count because it removes label-membership bookkeeping. The text-disabled controls remain unchanged. DOTS and stacked AREA have different label populations and save 44 and 42 allocations per frame respectively. Dynamic allocation summaries remain in the complete diagnostic output; different wall-clock fade states make their frame-to-frame totals less suitable as an exact causal control.
+
+### Longer settled-frame timing comparison
+
+Nine pairs, 5,000 measured frames/process, internal profiling disabled. Mean columns are medians of per-process means. “Paired change” is the median of `100 × (candidate_i / baseline_i − 1)`; it need not equal the ratio of the two displayed medians. “Paired p95 change” applies the same calculation to each pair's per-process p95. Negative means lower cost. IQR/min–max describe process variation, not confidence intervals.
+
+| Case | Baseline mean (ms) | Candidate mean (ms) | Median paired change | Paired min–max | Paired IQR | Paired p95 change |
+|---|---:|---:|---:|---:|---:|---:|
+| `warm-line-1` | 0.0226 | 0.0215 | -3.75% | -33.48 to +2.26% | 1.71 pp | -0.69% |
+| `warm-line-8` | 0.0314 | 0.0298 | -7.18% | -16.50 to +4.81% | 13.00 pp | -20.50% |
+| `warm-line-32` | 0.0640 | 0.0634 | -3.95% | -16.46 to +4.28% | 13.33 pp | -0.03% |
+| `dense-line-8` | 0.0321 | 0.0302 | -6.62% | -23.18 to +4.92% | 5.24 pp | -8.49% |
+| `warm-area-8` | 0.0309 | 0.0286 | -7.18% | -36.86 to +4.91% | 9.79 pp | -4.56% |
+| `warm-dots-8` | 0.0335 | 0.0326 | -4.40% | -21.63 to +24.63% | 5.72 pp | -4.78% |
+| `warm-line-8-no-text` | 0.0117 | 0.0116 | +0.58% | -38.05 to +21.69% | 10.88 pp | +2.17% |
+
+The text-workload median paired mean reductions amount to roughly **0.85–2.32 microseconds/frame**. Every selected text workload has both faster and slower individual pairs. Several individual paired p95 comparisons are worse, even though the displayed text-workload median paired p95 changes are negative. The no-text control has a +0.58% median paired mean change with much wider spread. These observations support a modest possible CPU-path benefit, not a general speedup or improved tail-latency claim.
+
+### Complete diagnostic matrix
+
+Five pairs, 240 measured frames/process, internal profiling enabled. These shorter, instrumented results help explain work and identify cases for follow-up. They are not substituted for the longer confirmation runs.
+
+| Case | Baseline mean (ms) | Candidate mean (ms) | Median paired change | Paired min–max | Paired IQR | Paired p95 change |
+|---|---:|---:|---:|---:|---:|---:|
+| `warm-line-1` | 0.0278 | 0.0251 | -9.63% | -38.77 to -5.12% | 9.16 pp | -22.68% |
+| `warm-line-8` | 0.0460 | 0.0358 | -8.18% | -37.81 to +9.18% | 29.42 pp | -13.66% |
+| `warm-line-32` | 0.0700 | 0.0670 | +0.67% | -7.01 to +7.73% | 3.07 pp | +13.46% |
+| `dense-line-8` | 0.0350 | 0.0343 | -7.54% | -22.03 to +0.76% | 16.61 pp | -10.67% |
+| `warm-area-8` | 0.0381 | 0.0348 | -2.99% | -39.37 to +24.30% | 17.16 pp | -9.55% |
+| `warm-stacked-area-8` | 0.0478 | 0.0456 | -3.62% | -6.42 to +2.47% | 2.69 pp | -2.58% |
+| `warm-dots-8` | 0.0365 | 0.0347 | -8.56% | -11.68 to +52.96% | 48.32 pp | -13.35% |
+| `pan-line-8` | 0.7136 | 0.6487 | -0.66% | -25.36 to +0.92% | 3.20 pp | -2.71% |
+| `zoom-line-8` | 1.5489 | 1.4255 | +0.23% | -24.28 to +6.89% | 3.16 pp | -2.44% |
+| `append-line-8` | 10.6955 | 11.0468 | +3.88% | -6.61 to +10.68% | 6.39 pp | +9.81% |
+| `wrap-line-8` | 9.8657 | 9.1146 | -7.00% | -8.96 to -1.60% | 5.30 pp | -11.77% |
+| `warm-line-8-no-text` | 0.0158 | 0.0146 | -9.39% | -37.59 to +39.04% | 6.89 pp | -21.40% |
+| `warm-line-8-conservative` | 2.6868 | 2.9864 | +8.72% | +2.72 to +27.40% | 4.64 pp | +6.01% |
+
+The append workload's +3.88% median paired change has mixed-sign pairs and remains unresolved. The conservative workload's +8.72% median paired change is positive in **all five pairs**, so it cannot be dismissed as harmless noise. Its range query and range scan counts are identical between variants: 3,840 of each per 240-frame run. Internal scopes put the additional time primarily before render passes, outside the changed text-label path. This localizes the observation but does not establish a cause.
+
+### Follow-up on the conservative slowdown
+
+Seven pairs, 500 measured frames/process, internal profiling disabled. The added no-text control keeps the same conservative range-scan contract while skipping the changed text path.
+
+| Case | Baseline mean (ms) | Candidate mean (ms) | Median paired change | Paired min–max | Paired IQR | Paired p95 change |
+|---|---:|---:|---:|---:|---:|---:|
+| `warm-line-8-conservative` | 2.6562 | 2.8748 | +4.12% | -1.33 to +16.22% | 6.72 pp | +3.25% |
+| `warm-line-8-conservative-no-text` | 2.7007 | 2.7973 | +7.50% | +0.99 to +9.77% | 4.30 pp | +3.90% |
+
+The slowdown persists, including **+7.50% median paired change with text disabled**, with all seven no-text pairs slower. That control retains exactly 130 allocations and 9,824 requested bytes per frame in both binaries. Executing the changed label logic is therefore not necessary for this observed slowdown. Binary layout, cache/allocator effects, or environmental effects remain possible explanations; none is established by these data. The result is a reason to investigate before accepting the production change as a general performance improvement. The allocation finding remains directly demonstrated.
+
+## What the work counters suggest for later optimization
+
+Settled stable-access LINE/AREA/DOTS cases have zero measured primary uploads, line-window uploads, monotonicity scans and auto-range scans after warmup. The dense case also reuses this work; its similar warm CPU cost is expected. A future change that accidentally invalidates those caches will fail the workload checks even if wall-time noise hides the regression.
+
+Streaming cases expose a substantially different cost. In `append-line-8`, each measured frame publishes only **128 new samples** in total, but the diagnostic baseline performs **16 primary uploads, 16 line-window uploads, 16 auto-range queries and 16 range scans per frame**. Across 240 measured frames it requests 673,689,600 primary-upload bytes and 673,812,480 line-window-upload bytes, about **5.35 MiB of combined requested upload traffic per frame**, and visits 45,803,520 samples in monotonicity scans. Both variants perform the same counted work. Those numbers describe renderer requests on Null, not hardware transfer bandwidth.
+
+This makes incremental range/window processing a concrete later investigation: reduce repeated work while holding publications, occupancy, overwrites and visible data fixed, then confirm frame-time improvement on a native backend. No such production optimization is included here. The conservative-access cases independently reveal the cost of repeated range scans, without conflating the public semantic contract with an implementation improvement.
+
+## Validation and remaining limits
+
+All **10 selected CTest registrations passed**: `ring_buffer_tests`, `brownian_generator_tests`, `benchmark_profiler_tests`, `benchmark_data_source_tests`, `benchmark_phase_trace_flush`, `benchmark_shared_frame_pipeline`, `benchmark_workload_contracts`, `benchmark_suite_validation`, `CoreAlgo`, and `LayoutCalculator`. The suite-validation registration runs nine Python checks; those nine checks were rerun successfully after the final runner changes. `git diff --check` also passed.
+
+The workload tests exercise the real Null renderer and check exact frame/publication counts, wrapped occupancy, motion, settled layout/range/upload reuse, frame-only mode and invalid input. The phase-trace flush test now defaults to Null because it tests durable output and external termination. Existing native smoke/readback tests retain their raster-backend requirement.
+
+This is focused validation, not a claim that every repository test or platform passed. Raster initialization was unavailable here: Xvfb could not create local sockets, minimal-EGL failed QPA surface configuration, and Qt's offscreen platform rejected Vulkan instance creation. Consequently **pixel equivalence, native presentation and GPU performance remain unverified**. The algorithm tests support fade semantics but do not replace native rendering/readback checks.
+
+Before promoting the experimental production change, reproduce the conservative control on a quieter machine/native renderer, investigate the pre-pass slowdown, and run the existing native text/readback tests. For future dynamic text optimizations, a controlled animation clock would make paired visual sequences stronger. These are limits on accepting that optimization, not blockers to using the benchmark suite.
+
+## Reproduce and extend
+
+Build the baseline at `88d459d` and the candidate at `70638b6` with identical dependencies and Release configuration. Use the final suite script from `5b40d72` (or its documentation-only descendants) for both. On a normal supported desktop, select an explicit backend such as `d3d11`, `metal`, `opengl` or `vulkan`; the runner rejects silent Null fallback. Refer to [building instructions](../../../docs/building.md) for dependency setup.
+
+Run the diagnostic suite with both executable paths:
+
+```bash
+python3 benchmark/tools/run_suite.py \
+  --baseline /absolute/baseline/vnm_plot_benchmark \
+  --candidate /absolute/candidate/vnm_plot_benchmark \
+  --graphics-backend opengl --repetitions 5 \
+  --warmup-frames 30 --frames 240 \
+  --output-dir results/diagnostic
+```
+
+The current default catalog includes all 14 cases. To reproduce the original 13-case diagnostic experiment exactly, pass those cases explicitly, excluding `warm-line-8-conservative-no-text`. Every original command is retained in the evidence archive's per-run `invocation.json`.
+
+For the longer confirmation experiment:
+
+```bash
+python3 benchmark/tools/run_suite.py \
+  --baseline /absolute/baseline/vnm_plot_benchmark \
+  --candidate /absolute/candidate/vnm_plot_benchmark \
+  --graphics-backend opengl --repetitions 9 \
+  --warmup-frames 100 --frames 5000 --frame-timing-only \
+  --cases warm-line-1 warm-line-8 warm-line-32 dense-line-8 \
+    warm-area-8 warm-dots-8 warm-line-8-no-text \
+  --output-dir results/outer
+```
+
+For the focused conservative controls, use seven repetitions, 30 warmup frames, 500 measured frames, `--frame-timing-only`, and `--cases warm-line-8-conservative warm-line-8-conservative-no-text`.
+
+For the Linux CPU-only environment used here, prefix the command with `taskset -c 8`, export `QT_QPA_PLATFORM=offscreen`, and replace the graphics backend with explicit `null`. Do not compare the resulting numbers directly against a raster-backend run. Use a new output directory each time; the runner deliberately refuses to overwrite evidence.
+
+Keep correctness checks separate from timing runs, retain raw evidence and exact build revisions, inspect work counters before interpreting elapsed time, and repeat without internal profiling when an apparent improvement matters. Accept a production optimization only after considering the complete workload matrix and its controls.
diff --git a/benchmark/results/2026-11-04-null/measurements.json b/benchmark/results/2026-11-04-null/measurements.json
new file mode 100644
index 00000000..16326d93
--- /dev/null
+++ b/benchmark/results/2026-11-04-null/measurements.json
@@ -0,0 +1,5594 @@
+{
+  "date": "2026-11-04",
+  "experiments": {
+    "final-conservative-controls": {
+      "cases": {
+        "warm-line-8-conservative": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 206,
+              "median": 206,
+              "min": 206,
+              "n": 7,
+              "q25": 206.0,
+              "q75": 206.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 168,
+              "median": 168,
+              "min": 168,
+              "n": 7,
+              "q25": 168.0,
+              "q75": 168.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 500.0,
+                "median": 500.0,
+                "min": 500.0
+              },
+              "candidate": {
+                "max": 500.0,
+                "median": 500.0,
+                "min": 500.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.22423683199999944,
+                "max": 2.8776561599999995,
+                "median": 2.6561767659999984,
+                "min": 2.534742338,
+                "n": 7,
+                "q25": 2.628072835,
+                "q75": 2.8523096669999997
+              },
+              "run_p95s": {
+                "iqr": 0.8357072500000013,
+                "max": 4.410432049999999,
+                "median": 3.199786999999997,
+                "min": 2.8470415499999997,
+                "n": 7,
+                "q25": 3.0052313749999984,
+                "q75": 3.8409386249999997
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.10872180999999781,
+                "max": 2.9605525459999966,
+                "median": 2.8748044640000003,
+                "min": 2.7656631579999984,
+                "n": 7,
+                "q25": 2.8078420390000014,
+                "q75": 2.916563848999999
+              },
+              "run_p95s": {
+                "iqr": 1.2442276249999997,
+                "max": 4.5733224,
+                "median": 3.6946462499999986,
+                "min": 3.0724540499999993,
+                "n": 7,
+                "q25": 3.28149185,
+                "q75": 4.525719475
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.17196365500000343,
+                "max": 0.41113826399999986,
+                "median": 0.10948639199999999,
+                "min": -0.03765560999999584,
+                "n": 7,
+                "q25": 0.048398829999996895,
+                "q75": 0.22036248500000033
+              },
+              "percent_change": {
+                "iqr": 6.72222571056793,
+                "max": 16.220120595152963,
+                "median": 4.121954284122364,
+                "min": -1.3299884253639704,
+                "n": 7,
+                "q25": 1.6822460376157422,
+                "q75": 8.404471748183672
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 1.736017825000001,
+                "max": 1.7254222499999998,
+                "median": 0.10411745000000305,
+                "min": -1.0338173000000004,
+                "n": 7,
+                "q25": -0.36562832499999987,
+                "q75": 1.370389500000001
+              },
+              "percent_change": {
+                "iqr": 52.46679678209935,
+                "max": 60.604041763984796,
+                "median": 3.2538868993468473,
+                "min": -24.08204548977544,
+                "n": 7,
+                "q25": -8.365195866866086,
+                "q75": 44.10160091523326
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 14464,
+              "median": 14464,
+              "min": 14464,
+              "n": 7,
+              "q25": 14464.0,
+              "q75": 14464.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 13568,
+              "median": 13568,
+              "min": 13568,
+              "n": 7,
+              "q25": 13568.0,
+              "q75": 13568.0
+            }
+          }
+        },
+        "warm-line-8-conservative-no-text": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 130,
+              "median": 130,
+              "min": 130,
+              "n": 7,
+              "q25": 130.0,
+              "q75": 130.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 130,
+              "median": 130,
+              "min": 130,
+              "n": 7,
+              "q25": 130.0,
+              "q75": 130.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 500.0,
+                "median": 500.0,
+                "min": 500.0
+              },
+              "candidate": {
+                "max": 500.0,
+                "median": 500.0,
+                "min": 500.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.125682395000001,
+                "max": 2.876927938000001,
+                "median": 2.700683873999999,
+                "min": 2.536286702000001,
+                "n": 7,
+                "q25": 2.624701611999999,
+                "q75": 2.750384007
+              },
+              "run_p95s": {
+                "iqr": 1.301142425000001,
+                "max": 4.4954047999999975,
+                "median": 3.2965088499999995,
+                "min": 2.819516,
+                "n": 7,
+                "q25": 3.0850485999999986,
+                "q75": 4.386191025
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.14994843300000227,
+                "max": 3.1581120999999994,
+                "median": 2.797284470000003,
+                "min": 2.6784088260000023,
+                "n": 7,
+                "q25": 2.7653987179999993,
+                "q75": 2.9153471510000015
+              },
+              "run_p95s": {
+                "iqr": 0.7434171249999992,
+                "max": 4.6705764,
+                "median": 3.5329019499999985,
+                "min": 2.9826514,
+                "n": 7,
+                "q25": 3.1442068249999995,
+                "q75": 3.8876239499999987
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.11992868900000042,
+                "max": 0.2811841619999984,
+                "median": 0.19165484399999988,
+                "min": 0.027376813999998806,
+                "n": 7,
+                "q25": 0.09778854600000231,
+                "q75": 0.21771723500000273
+              },
+              "percent_change": {
+                "iqr": 4.295223830656745,
+                "max": 9.773764517559425,
+                "median": 7.501675222844595,
+                "min": 0.9930150375438984,
+                "n": 7,
+                "q25": 3.775869800127729,
+                "q75": 8.071093630784475
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.3489078999999986,
+                "max": 0.4409385499999998,
+                "median": 0.17517160000000231,
+                "min": -1.27357005,
+                "n": 7,
+                "q25": -0.08611837499999941,
+                "q75": 0.2627895249999992
+              },
+              "percent_change": {
+                "iqr": 10.073988541336792,
+                "max": 13.376806733008785,
+                "median": 3.8966813400208578,
+                "min": -28.59846112364214,
+                "n": 7,
+                "q25": -1.36019107467758,
+                "q75": 8.713797466659212
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 9824,
+              "median": 9824,
+              "min": 9824,
+              "n": 7,
+              "q25": 9824.0,
+              "q75": 9824.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 9824,
+              "median": 9824,
+              "min": 9824,
+              "n": 7,
+              "q25": 9824.0,
+              "q75": 9824.0
+            }
+          }
+        }
+      },
+      "created_at": "2026-11-04T00:21:14.785534+00:00",
+      "ended_at": "2026-11-04T00:21:58.876251+00:00",
+      "executables": {
+        "baseline": {
+          "bytes": 2058480,
+          "git_at_binary_location": null,
+          "path": "/workspace/scratch/09f16afbdc00/evidence/bin/vnm_plot_benchmark_baseline_v2",
+          "sha256": "a421c9d8832519110d6bc0eb2253916798eef0d30512f5359f46673c51f29f5d"
+        },
+        "candidate": {
+          "bytes": 2053392,
+          "git_at_binary_location": null,
+          "path": "/workspace/scratch/09f16afbdc00/evidence/bin/vnm_plot_benchmark_candidate_v2",
+          "sha256": "77cfcf554e536ae0adfb4575ae8e7cf89623aa13fa99003e7df5088b96b21c9d"
+        }
+      },
+      "frames": 500,
+      "host": {
+        "cpu_affinity": [
+          8
+        ],
+        "cpu_count": 9,
+        "cpu_model": "AMD EPYC 9V74 80-Core Processor",
+        "machine": "x86_64",
+        "platform": "Linux-6.18.57-x86_64-with-glibc2.39",
+        "python": "3.12.3",
+        "renderer_environment": {
+          "GALLIUM_DRIVER": null,
+          "LIBGL_ALWAYS_SOFTWARE": null,
+          "LP_NUM_THREADS": null,
+          "MESA_LOADER_DRIVER_OVERRIDE": null,
+          "QSG_RENDER_LOOP": null,
+          "QSG_RHI_BACKEND": null,
+          "QT_FONT_DPI": null,
+          "QT_QPA_PLATFORM": "offscreen",
+          "QT_SCALE_FACTOR": null,
+          "QT_SCREEN_SCALE_FACTORS": null,
+          "XDG_CACHE_HOME": null
+        }
+      },
+      "internal_profiling": false,
+      "repetitions": 7,
+      "warmup_frames": 30
+    },
+    "final-paired-diagnostic": {
+      "cases": {
+        "append-line-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 315.6458333333333,
+              "median": 315.6458333333333,
+              "min": 315.6458333333333,
+              "n": 5,
+              "q25": 315.6458333333333,
+              "q75": 315.6458333333333
+            },
+            "candidate": {
+              "iqr": 0.004166666666662877,
+              "max": 277.3666666666667,
+              "median": 277.3625,
+              "min": 277.3625,
+              "n": 5,
+              "q25": 277.3625,
+              "q75": 277.3666666666667
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 110720.0,
+                "median": 110720.0,
+                "min": 110720.0
+              },
+              "candidate": {
+                "max": 110720.0,
+                "median": 110720.0,
+                "min": 110720.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 30720.0,
+                "median": 30720.0,
+                "min": 30720.0
+              },
+              "candidate": {
+                "max": 30720.0,
+                "median": 30720.0,
+                "min": 30720.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 16.0,
+                "median": 16.0,
+                "min": 16.0
+              },
+              "candidate": {
+                "max": 16.0,
+                "median": 16.0,
+                "min": 16.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 673812480.0,
+                "median": 673812480.0,
+                "min": 673812480.0
+              },
+              "candidate": {
+                "max": 673812480.0,
+                "median": 673812480.0,
+                "min": 673812480.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 673689600.0,
+                "median": 673689600.0,
+                "min": 673689600.0
+              },
+              "candidate": {
+                "max": 673689600.0,
+                "median": 673689600.0,
+                "min": 673689600.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 45803520.0,
+                "median": 45803520.0,
+                "min": 45803520.0
+              },
+              "candidate": {
+                "max": 45803520.0,
+                "median": 45803520.0,
+                "min": 45803520.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.7270337250000054,
+                "max": 12.512332187500009,
+                "median": 10.695530670833334,
+                "min": 9.895492795833336,
+                "n": 5,
+                "q25": 9.974477929166666,
+                "q75": 10.701511654166671
+              },
+              "run_p95s": {
+                "iqr": 0.5443745500000148,
+                "max": 17.57215085,
+                "median": 13.63338769999999,
+                "min": 11.809166350000002,
+                "n": 5,
+                "q25": 13.455876449999984,
+                "q75": 14.000250999999999
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.07032982916666874,
+                "max": 11.684657737499991,
+                "median": 11.046785895833331,
+                "min": 10.846652479166673,
+                "n": 5,
+                "q25": 11.03978627083334,
+                "q75": 11.110116100000008
+              },
+              "run_p95s": {
+                "iqr": 1.3468514000000003,
+                "max": 16.2120635,
+                "median": 14.971037849999998,
+                "min": 14.151860749999997,
+                "n": 5,
+                "q25": 14.4652456,
+                "q75": 15.812097
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.6058854416666772,
+                "max": 1.0653083416666735,
+                "median": 0.4145854291666744,
+                "min": -0.8276744500000177,
+                "n": 5,
+                "q25": 0.3452742416666599,
+                "q75": 0.9511596833333371
+              },
+              "percent_change": {
+                "iqr": 6.385643419551168,
+                "max": 10.680341860816323,
+                "median": 3.8762492664085046,
+                "min": -6.614869535088552,
+                "n": 5,
+                "q25": 3.2264062575890984,
+                "q75": 9.612049677140266
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 1.877699799999995,
+                "max": 2.3562205500000157,
+                "median": 1.3376501500000089,
+                "min": -1.3600873500000006,
+                "n": 5,
+                "q25": 0.4649946000000007,
+                "q75": 2.3426943999999956
+              },
+              "percent_change": {
+                "iqr": 14.189387326822022,
+                "max": 19.837932082309905,
+                "median": 9.811575665819362,
+                "min": -7.740016356620338,
+                "n": 5,
+                "q25": 3.321330453289728,
+                "q75": 17.51071778011175
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 143249.56666666668,
+              "median": 143249.56666666668,
+              "min": 143249.56666666668,
+              "n": 5,
+              "q25": 143249.56666666668,
+              "q75": 143249.56666666668
+            },
+            "candidate": {
+              "iqr": 5.333333333343035,
+              "max": 142354.36666666667,
+              "median": 142349.03333333333,
+              "min": 142349.03333333333,
+              "n": 5,
+              "q25": 142349.03333333333,
+              "q75": 142354.36666666667
+            }
+          }
+        },
+        "dense-line-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 190,
+              "median": 190,
+              "min": 190,
+              "n": 5,
+              "q25": 190.0,
+              "q75": 190.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 152,
+              "median": 152,
+              "min": 152,
+              "n": 5,
+              "q25": 152.0,
+              "q75": 152.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 800000.0,
+                "median": 800000.0,
+                "min": 800000.0
+              },
+              "candidate": {
+                "max": 800000.0,
+                "median": 800000.0,
+                "min": 800000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.007004070833333334,
+                "max": 0.044199433333333316,
+                "median": 0.03500291666666667,
+                "min": 0.03355288333333333,
+                "n": 5,
+                "q25": 0.03395258749999999,
+                "q75": 0.040956658333333326
+              },
+              "run_p95s": {
+                "iqr": 0.01472559999999997,
+                "max": 0.11153094999999989,
+                "median": 0.047701549999999995,
+                "min": 0.03882104999999988,
+                "n": 5,
+                "q25": 0.04472554999999999,
+                "q75": 0.05945114999999996
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.000419204166666666,
+                "max": 0.035269212499999994,
+                "median": 0.03426354583333333,
+                "min": 0.031023833333333337,
+                "n": 5,
+                "q25": 0.03404298333333334,
+                "q75": 0.034462187500000005
+              },
+              "run_p95s": {
+                "iqr": 0.017597549999999997,
+                "max": 0.06359150000000001,
+                "median": 0.05103619999999996,
+                "min": 0.034680499999999996,
+                "n": 5,
+                "q25": 0.04578869999999995,
+                "q75": 0.06338624999999995
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.006783508333333341,
+                "max": 0.0002662958333333257,
+                "median": -0.0025290499999999945,
+                "min": -0.00973724583333331,
+                "n": 5,
+                "q25": -0.006693112499999994,
+                "q75": 9.039583333334683e-05
+              },
+              "percent_change": {
+                "iqr": 16.608181292416145,
+                "max": 0.760781839608593,
+                "median": -7.537504228399627,
+                "min": -22.030250387825447,
+                "n": 5,
+                "q25": -16.34193992470494,
+                "q75": 0.2662413677112063
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.016997099999999973,
+                "max": 0.01886595000000002,
+                "median": -0.004140549999999882,
+                "min": -0.04814469999999994,
+                "n": 5,
+                "q25": -0.013662450000000007,
+                "q75": 0.003334649999999967
+              },
+              "percent_change": {
+                "iqr": 29.97162175206649,
+                "max": 42.18159418945105,
+                "median": -10.665734182872166,
+                "min": -43.16712087541619,
+                "n": 5,
+                "q25": -22.980968408516933,
+                "q75": 6.990653343549558
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 13952,
+              "median": 13952,
+              "min": 13952,
+              "n": 5,
+              "q25": 13952.0,
+              "q75": 13952.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 13056,
+              "median": 13056,
+              "min": 13056,
+              "n": 5,
+              "q25": 13056.0,
+              "q75": 13056.0
+            }
+          }
+        },
+        "pan-line-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 247.475,
+              "median": 247.475,
+              "min": 247.475,
+              "n": 5,
+              "q25": 247.475,
+              "q75": 247.475
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 203.975,
+              "median": 203.975,
+              "min": 203.975,
+              "n": 5,
+              "q25": 203.975,
+              "q75": 203.975
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 76952832.0,
+                "median": 76952832.0,
+                "min": 76952832.0
+              },
+              "candidate": {
+                "max": 76952832.0,
+                "median": 76952832.0,
+                "min": 76952832.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 1920.0,
+                "median": 1920.0,
+                "min": 1920.0
+              },
+              "candidate": {
+                "max": 1920.0,
+                "median": 1920.0,
+                "min": 1920.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 76891392.0,
+                "median": 76891392.0,
+                "min": 76891392.0
+              },
+              "candidate": {
+                "max": 76891392.0,
+                "median": 76891392.0,
+                "min": 76891392.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 1920.0,
+                "median": 1920.0,
+                "min": 1920.0
+              },
+              "candidate": {
+                "max": 1920.0,
+                "median": 1920.0,
+                "min": 1920.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.05428784166666578,
+                "max": 0.8691801124999994,
+                "median": 0.7136060041666672,
+                "min": 0.6473559416666663,
+                "n": 5,
+                "q25": 0.6603511083333334,
+                "q75": 0.7146389499999992
+              },
+              "run_p95s": {
+                "iqr": 0.20139939999999967,
+                "max": 1.1234899999999999,
+                "median": 0.92619965,
+                "min": 0.7336621499999998,
+                "n": 5,
+                "q25": 0.7632848,
+                "q75": 0.9646841999999997
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.06249812499999996,
+                "max": 0.720138591666666,
+                "median": 0.6487393583333336,
+                "min": 0.6392943333333335,
+                "n": 5,
+                "q25": 0.6474249458333338,
+                "q75": 0.7099230708333337
+              },
+              "run_p95s": {
+                "iqr": 0.14453234999999975,
+                "max": 0.9849189499999998,
+                "median": 0.76247955,
+                "min": 0.7406852499999997,
+                "n": 5,
+                "q25": 0.75654055,
+                "q75": 0.9010728999999997
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.021125779166667358,
+                "max": 0.006532587499998854,
+                "median": -0.004715879166665493,
+                "min": -0.22044075416666575,
+                "n": 5,
+                "q25": -0.021056774999999917,
+                "q75": 6.900416666744125e-05
+              },
+              "percent_change": {
+                "iqr": 3.1993834953844003,
+                "max": 0.9154333710557072,
+                "median": -0.6598967445960668,
+                "min": -25.361918777986993,
+                "n": 5,
+                "q25": -3.1887241096854257,
+                "q75": 0.01065938569897451
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.0453615000000005,
+                "max": 0.028817400000000215,
+                "median": -0.022599550000000246,
+                "min": -0.3669494499999999,
+                "n": 5,
+                "q25": -0.02512675000000031,
+                "q75": 0.02023475000000019
+              },
+              "percent_change": {
+                "iqr": 5.058379706686756,
+                "max": 3.927884244812163,
+                "median": -2.7128870109160874,
+                "min": -32.6615679712325,
+                "n": 5,
+                "q25": -2.9608279897621714,
+                "q75": 2.097551716924584
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 28800.4,
+              "median": 28800.4,
+              "min": 28800.4,
+              "n": 5,
+              "q25": 28800.4,
+              "q75": 28800.4
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 27768.4,
+              "median": 27768.4,
+              "min": 27768.4,
+              "n": 5,
+              "q25": 27768.4,
+              "q75": 27768.4
+            }
+          }
+        },
+        "warm-area-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 190,
+              "median": 190,
+              "min": 190,
+              "n": 5,
+              "q25": 190.0,
+              "q75": 190.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 152,
+              "median": 152,
+              "min": 152,
+              "n": 5,
+              "q25": 152.0,
+              "q75": 152.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.0026264041666666307,
+                "max": 0.054135624999999986,
+                "median": 0.03814157916666664,
+                "min": 0.033105224999999995,
+                "n": 5,
+                "q25": 0.036077645833333366,
+                "q75": 0.03870405
+              },
+              "run_p95s": {
+                "iqr": 0.02860390000000003,
+                "max": 0.08455129999999993,
+                "median": 0.0729842999999997,
+                "min": 0.041554649999999964,
+                "n": 5,
+                "q25": 0.05103959999999998,
+                "q75": 0.0796435
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.006283545833333307,
+                "max": 0.04810889583333333,
+                "median": 0.03479525833333333,
+                "min": 0.03211442500000001,
+                "n": 5,
+                "q25": 0.03282087083333334,
+                "q75": 0.03910441666666665
+              },
+              "run_p95s": {
+                "iqr": 0.015801000000000016,
+                "max": 0.08601095,
+                "median": 0.061609549999999874,
+                "min": 0.04530354999999999,
+                "n": 5,
+                "q25": 0.05021269999999995,
+                "q75": 0.06601369999999997
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.006373091666666594,
+                "max": 0.009404845833333335,
+                "median": -0.0009907999999999861,
+                "min": -0.021314754166666644,
+                "n": 5,
+                "q25": -0.003346320833333312,
+                "q75": 0.0030267708333332824
+              },
+              "percent_change": {
+                "iqr": 17.163021558877823,
+                "max": 24.29938425909779,
+                "median": -2.992881033129924,
+                "min": -39.3728790730072,
+                "n": 5,
+                "q25": -8.773419733648014,
+                "q75": 8.389601825229809
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.02669065000000008,
+                "max": 0.034971350000000026,
+                "median": -0.00697059999999973,
+                "min": -0.029430800000000056,
+                "n": 5,
+                "q25": -0.022941750000000052,
+                "q75": 0.003748900000000027
+              },
+              "percent_change": {
+                "iqr": 36.15514092585781,
+                "max": 68.51807224194555,
+                "median": -9.550821204012038,
+                "min": -36.9531725752887,
+                "n": 5,
+                "q25": -27.133527219569743,
+                "q75": 9.021613706288068
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 13952,
+              "median": 13952,
+              "min": 13952,
+              "n": 5,
+              "q25": 13952.0,
+              "q75": 13952.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 13056,
+              "median": 13056,
+              "min": 13056,
+              "n": 5,
+              "q25": 13056.0,
+              "q75": 13056.0
+            }
+          }
+        },
+        "warm-dots-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 186,
+              "median": 186,
+              "min": 186,
+              "n": 5,
+              "q25": 186.0,
+              "q75": 186.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 142,
+              "median": 142,
+              "min": 142,
+              "n": 5,
+              "q25": 142.0,
+              "q75": 142.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.0006956666666666569,
+                "max": 0.038282512499999984,
+                "median": 0.03653851666666665,
+                "min": 0.03557049166666667,
+                "n": 5,
+                "q25": 0.036242604166666685,
+                "q75": 0.03693827083333334
+              },
+              "run_p95s": {
+                "iqr": 0.0028630999999997436,
+                "max": 0.05902029999999992,
+                "median": 0.05131919999999996,
+                "min": 0.047866599999999974,
+                "n": 5,
+                "q25": 0.04887704999999999,
+                "q75": 0.051740149999999735
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.016969537499999986,
+                "max": 0.05440857083333332,
+                "median": 0.034720466666666686,
+                "min": 0.03262443750000002,
+                "n": 5,
+                "q25": 0.03341176249999999,
+                "q75": 0.050381299999999976
+              },
+              "run_p95s": {
+                "iqr": 0.03052120000000009,
+                "max": 0.1254167499999996,
+                "median": 0.051140549999999986,
+                "min": 0.03558459999999998,
+                "n": 5,
+                "q25": 0.03936984999999991,
+                "q75": 0.06989105
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.01770074166666659,
+                "max": 0.018838079166666653,
+                "median": -0.003126754166666662,
+                "min": -0.004313833333333322,
+                "n": 5,
+                "q25": -0.003562045833333298,
+                "q75": 0.014138695833333291
+              },
+              "percent_change": {
+                "iqr": 48.31588723557485,
+                "max": 52.959850381601385,
+                "median": -8.557419544945944,
+                "min": -11.67849289101126,
+                "n": 5,
+                "q25": -9.304629191548752,
+                "q75": 39.0112580440261
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.02807905000000012,
+                "max": 0.07755014999999962,
+                "median": -0.007879749999999935,
+                "min": -0.016155549999999755,
+                "n": 5,
+                "q25": -0.009507200000000084,
+                "q75": 0.018571850000000036
+              },
+              "percent_change": {
+                "iqr": 55.6401480193981,
+                "max": 162.013073834364,
+                "median": -13.350914854719386,
+                "min": -31.224397300741956,
+                "n": 5,
+                "q25": -19.45125575295581,
+                "q75": 36.18889226644229
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 14464,
+              "median": 14464,
+              "min": 14464,
+              "n": 5,
+              "q25": 14464.0,
+              "q75": 14464.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 13424,
+              "median": 13424,
+              "min": 13424,
+              "n": 5,
+              "q25": 13424.0,
+              "q75": 13424.0
+            }
+          }
+        },
+        "warm-line-1": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 99,
+              "median": 99,
+              "min": 99,
+              "n": 5,
+              "q25": 99.0,
+              "q75": 99.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 61,
+              "median": 61,
+              "min": 61,
+              "n": 5,
+              "q25": 61.0,
+              "q75": 61.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 10000.0,
+                "median": 10000.0,
+                "min": 10000.0
+              },
+              "candidate": {
+                "max": 10000.0,
+                "median": 10000.0,
+                "min": 10000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.010848525000000036,
+                "max": 0.038462720833333325,
+                "median": 0.027801679166666655,
+                "min": 0.025415141666666658,
+                "n": 5,
+                "q25": 0.026619945833333315,
+                "q75": 0.03746847083333335
+              },
+              "run_p95s": {
+                "iqr": 0.012755299999999949,
+                "max": 0.05670249999999999,
+                "median": 0.0524159499999999,
+                "min": 0.03473859999999999,
+                "n": 5,
+                "q25": 0.04250799999999988,
+                "q75": 0.05526329999999983
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.0021684916666666713,
+                "max": 0.03142141666666667,
+                "median": 0.025123483333333325,
+                "min": 0.02294277916666667,
+                "n": 5,
+                "q25": 0.02308977500000001,
+                "q75": 0.02525826666666668
+              },
+              "run_p95s": {
+                "iqr": 0.0003422500000000439,
+                "max": 0.09360014999999997,
+                "median": 0.03286789999999991,
+                "min": 0.026872099999999986,
+                "n": 5,
+                "q25": 0.03282379999999994,
+                "q75": 0.03316604999999998
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.00471593750000001,
+                "max": -0.001361679166666633,
+                "median": -0.0026781958333333307,
+                "min": -0.01452569166666668,
+                "n": 5,
+                "q25": -0.007041304166666658,
+                "q75": -0.002325366666666648
+              },
+              "percent_change": {
+                "iqr": 9.157295472415628,
+                "max": -5.11525896856464,
+                "median": -9.63321609920743,
+                "min": -38.767772859692165,
+                "n": 5,
+                "q25": -18.30682805092765,
+                "q75": -9.149532578512021
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.020866949999999884,
+                "max": 0.04118420000000007,
+                "median": -0.009640099999999971,
+                "min": -0.029830400000000003,
+                "n": 5,
+                "q25": -0.02243949999999989,
+                "q75": -0.0015725500000000059
+              },
+              "percent_change": {
+                "iqr": 36.07789631688292,
+                "max": 78.57188508459762,
+                "median": -22.678319375176436,
+                "min": -52.60861514042592,
+                "n": 5,
+                "q25": -40.604705111710594,
+                "q75": -4.526808794827675
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 7400,
+              "median": 7400,
+              "min": 7400,
+              "n": 5,
+              "q25": 7400.0,
+              "q75": 7400.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 6504,
+              "median": 6504,
+              "min": 6504,
+              "n": 5,
+              "q25": 6504.0,
+              "q75": 6504.0
+            }
+          }
+        },
+        "warm-line-32": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 502,
+              "median": 502,
+              "min": 502,
+              "n": 5,
+              "q25": 502.0,
+              "q75": 502.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 464,
+              "median": 464,
+              "min": 464,
+              "n": 5,
+              "q25": 464.0,
+              "q75": 464.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 320000.0,
+                "median": 320000.0,
+                "min": 320000.0
+              },
+              "candidate": {
+                "max": 320000.0,
+                "median": 320000.0,
+                "min": 320000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.006015058333333295,
+                "max": 0.07206676249999996,
+                "median": 0.070044175,
+                "min": 0.06156886249999998,
+                "n": 5,
+                "q25": 0.06553318750000002,
+                "q75": 0.07154824583333332
+              },
+              "run_p95s": {
+                "iqr": 0.03944734999999991,
+                "max": 0.13685609999999998,
+                "median": 0.11098744999999968,
+                "min": 0.07736149999999999,
+                "n": 5,
+                "q25": 0.09585450000000001,
+                "q75": 0.13530184999999992
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.004055587500000027,
+                "max": 0.07708131250000003,
+                "median": 0.0670166666666667,
+                "min": 0.06344344166666668,
+                "n": 5,
+                "q25": 0.06597390416666665,
+                "q75": 0.07002949166666668
+              },
+              "run_p95s": {
+                "iqr": 0.03672690000000001,
+                "max": 0.15351719999999996,
+                "median": 0.10443539999999957,
+                "min": 0.09267474999999982,
+                "n": 5,
+                "q25": 0.09481414999999996,
+                "q75": 0.13154104999999996
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.0018892625000000232,
+                "max": 0.005533066666666711,
+                "median": 0.00044071666666663234,
+                "min": -0.005050095833333268,
+                "n": 5,
+                "q25": -1.4683333333320725e-05,
+                "q75": 0.0018745791666667025
+              },
+              "percent_change": {
+                "iqr": 3.065649984221064,
+                "max": 7.733336579006567,
+                "median": 0.6725091262600902,
+                "min": -7.007524215248706,
+                "n": 5,
+                "q25": -0.020962961350201592,
+                "q75": 3.0446870228708622
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.009634450000000488,
+                "max": 0.020553600000000283,
+                "median": 0.015313249999999834,
+                "min": -0.04204195000000002,
+                "n": 5,
+                "q25": 0.008580899999999558,
+                "q75": 0.018215350000000047
+              },
+              "percent_change": {
+                "iqr": 9.566845171566808,
+                "max": 19.794406778565367,
+                "median": 13.462750139780088,
+                "min": -30.719821768996802,
+                "n": 5,
+                "q25": 8.95200538315839,
+                "q75": 18.518850554725198
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 36416,
+              "median": 36416,
+              "min": 36416,
+              "n": 5,
+              "q25": 36416.0,
+              "q75": 36416.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 35520,
+              "median": 35520,
+              "min": 35520,
+              "n": 5,
+              "q25": 35520.0,
+              "q75": 35520.0
+            }
+          }
+        },
+        "warm-line-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 190,
+              "median": 190,
+              "min": 190,
+              "n": 5,
+              "q25": 190.0,
+              "q75": 190.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 152,
+              "median": 152,
+              "min": 152,
+              "n": 5,
+              "q25": 152.0,
+              "q75": 152.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.01546670416666663,
+                "max": 0.05600119166666665,
+                "median": 0.04596148749999998,
+                "min": 0.03430499166666667,
+                "n": 5,
+                "q25": 0.035067895833333335,
+                "q75": 0.050534599999999964
+              },
+              "run_p95s": {
+                "iqr": 0.018058800000000062,
+                "max": 0.12346449999999977,
+                "median": 0.05968679999999993,
+                "min": 0.04707714999999998,
+                "n": 5,
+                "q25": 0.051122199999999944,
+                "q75": 0.069181
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.004712116666666662,
+                "max": 0.04220055833333332,
+                "median": 0.03581192916666666,
+                "min": 0.03142857500000001,
+                "n": 5,
+                "q25": 0.03274277916666668,
+                "q75": 0.03745489583333334
+              },
+              "run_p95s": {
+                "iqr": 0.02102549999999999,
+                "max": 0.07243214999999974,
+                "median": 0.056612849999999805,
+                "min": 0.037472849999999926,
+                "n": 5,
+                "q25": 0.044141149999999976,
+                "q75": 0.06516664999999996
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.016780908333333303,
+                "max": 0.0031499041666666686,
+                "median": -0.0037609291666666628,
+                "min": -0.020189262499999992,
+                "n": 5,
+                "q25": -0.019106024999999957,
+                "q75": -0.0023251166666666545
+              },
+              "percent_change": {
+                "iqr": 29.42115886885548,
+                "max": 9.182057810342958,
+                "median": -8.182783828888617,
+                "min": -37.80780890716454,
+                "n": 5,
+                "q25": -36.05148729721971,
+                "q75": -6.63032842836423
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.028634199999999957,
+                "max": 0.02535499999999976,
+                "median": -0.006981049999999968,
+                "min": -0.058297849999999804,
+                "n": 5,
+                "q25": -0.03170815000000008,
+                "q75": -0.003073950000000124
+              },
+              "percent_change": {
+                "iqr": 40.68347668645092,
+                "max": 53.858400519147345,
+                "median": -13.655613412568268,
+                "min": -47.218309716558124,
+                "n": 5,
+                "q25": -45.833610384354195,
+                "q75": -5.15013369790327
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 13952,
+              "median": 13952,
+              "min": 13952,
+              "n": 5,
+              "q25": 13952.0,
+              "q75": 13952.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 13056,
+              "median": 13056,
+              "min": 13056,
+              "n": 5,
+              "q25": 13056.0,
+              "q75": 13056.0
+            }
+          }
+        },
+        "warm-line-8-conservative": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 206,
+              "median": 206,
+              "min": 206,
+              "n": 5,
+              "q25": 206.0,
+              "q75": 206.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 168,
+              "median": 168,
+              "min": 168,
+              "n": 5,
+              "q25": 168.0,
+              "q75": 168.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.1641587708333332,
+                "max": 2.8667194791666684,
+                "median": 2.6868492958333334,
+                "min": 2.6193387208333334,
+                "n": 5,
+                "q25": 2.629331479166666,
+                "q75": 2.793490249999999
+              },
+              "run_p95s": {
+                "iqr": 0.4462047999999976,
+                "max": 4.405091099999999,
+                "median": 3.1626072499999984,
+                "min": 2.9231760999999996,
+                "n": 5,
+                "q25": 3.0136872999999995,
+                "q75": 3.459892099999997
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.09217644583333229,
+                "max": 3.3496932750000004,
+                "median": 2.9863994208333344,
+                "min": 2.7898975625,
+                "n": 5,
+                "q25": 2.9447874499999998,
+                "q75": 3.036963895833332
+              },
+              "run_p95s": {
+                "iqr": 0.6636560499999935,
+                "max": 4.71374085,
+                "median": 3.7655914499999987,
+                "min": 3.0855735999999996,
+                "n": 5,
+                "q25": 3.35254205,
+                "q75": 4.016198099999993
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.1289912833333342,
+                "max": 0.7203617958333344,
+                "median": 0.24347364583333286,
+                "min": 0.07806797083333139,
+                "n": 5,
+                "q25": 0.1705588416666668,
+                "q75": 0.299550125000001
+              },
+              "percent_change": {
+                "iqr": 4.637227586561377,
+                "max": 27.397146443537967,
+                "median": 8.715750693360501,
+                "min": 2.7232511377787594,
+                "n": 5,
+                "q25": 6.511522939362502,
+                "q75": 11.148750525923878
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.23381305000000152,
+                "max": 1.7905647500000001,
+                "median": 0.1899348000000014,
+                "min": -0.3888930000000057,
+                "n": 5,
+                "q25": 0.07188630000000007,
+                "q75": 0.3056993500000016
+              },
+              "percent_change": {
+                "iqr": 6.450189760708591,
+                "max": 61.25408421340064,
+                "median": 6.005639808736962,
+                "min": -8.828262371236907,
+                "n": 5,
+                "q25": 2.3853271041093027,
+                "q75": 8.835516864817894
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 14464,
+              "median": 14464,
+              "min": 14464,
+              "n": 5,
+              "q25": 14464.0,
+              "q75": 14464.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 13568,
+              "median": 13568,
+              "min": 13568,
+              "n": 5,
+              "q25": 13568.0,
+              "q75": 13568.0
+            }
+          }
+        },
+        "warm-line-8-no-text": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 114,
+              "median": 114,
+              "min": 114,
+              "n": 5,
+              "q25": 114.0,
+              "q75": 114.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 114,
+              "median": 114,
+              "min": 114,
+              "n": 5,
+              "q25": 114.0,
+              "q75": 114.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.0027541083333333296,
+                "max": 0.022548299999999997,
+                "median": 0.0157936875,
+                "min": 0.014291895833333328,
+                "n": 5,
+                "q25": 0.015142524999999995,
+                "q75": 0.017896633333333325
+              },
+              "run_p95s": {
+                "iqr": 0.008222049999999984,
+                "max": 0.032587549999999986,
+                "median": 0.01981095,
+                "min": 0.015822999999999997,
+                "n": 5,
+                "q25": 0.017375099999999984,
+                "q75": 0.025597149999999968
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.002111195833333324,
+                "max": 0.0198712875,
+                "median": 0.014566050000000004,
+                "min": 0.0140720625,
+                "n": 5,
+                "q25": 0.014105000000000012,
+                "q75": 0.016216195833333336
+              },
+              "run_p95s": {
+                "iqr": 0.0022925499999999904,
+                "max": 0.043983599999999984,
+                "median": 0.016507499999999998,
+                "min": 0.015398549999999995,
+                "n": 5,
+                "q25": 0.015570499999999994,
+                "q75": 0.017863049999999984
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.0011122124999999976,
+                "max": 0.005579391666666673,
+                "median": -0.0016804374999999892,
+                "min": -0.008476237499999997,
+                "n": 5,
+                "q25": -0.0016886874999999888,
+                "q75": -0.0005764749999999912
+              },
+              "percent_change": {
+                "iqr": 6.885173481350216,
+                "max": 39.0388492312806,
+                "median": -9.389685024557636,
+                "min": -37.59147031040033,
+                "n": 5,
+                "q25": -10.692167361168748,
+                "q75": -3.806993879818532
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.009330999999999987,
+                "max": 0.028160599999999987,
+                "median": -0.004240450000000007,
+                "min": -0.014724500000000001,
+                "n": 5,
+                "q25": -0.010198599999999973,
+                "q75": -0.0008675999999999857
+              },
+              "percent_change": {
+                "iqr": 34.84936430871922,
+                "max": 177.97257157302658,
+                "median": -21.404576761841344,
+                "min": -45.18443393259084,
+                "n": 5,
+                "q25": -39.84271686496342,
+                "q75": -4.993352556244202
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 9312,
+              "median": 9312,
+              "min": 9312,
+              "n": 5,
+              "q25": 9312.0,
+              "q75": 9312.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 9312,
+              "median": 9312,
+              "min": 9312,
+              "n": 5,
+              "q25": 9312.0,
+              "q75": 9312.0
+            }
+          }
+        },
+        "warm-stacked-area-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 246,
+              "median": 246,
+              "min": 246,
+              "n": 5,
+              "q25": 246.0,
+              "q75": 246.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 204,
+              "median": 204,
+              "min": 204,
+              "n": 5,
+              "q25": 204.0,
+              "q75": 204.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.stacking.cache_hit_count": {
+              "baseline": {
+                "max": 480.0,
+                "median": 480.0,
+                "min": 480.0
+              },
+              "candidate": {
+                "max": 480.0,
+                "median": 480.0,
+                "min": 480.0
+              }
+            },
+            "renderer.stacking.output_sample_count": {
+              "baseline": {
+                "max": 9089280.0,
+                "median": 9089280.0,
+                "min": 9089280.0
+              },
+              "candidate": {
+                "max": 9089280.0,
+                "median": 9089280.0,
+                "min": 9089280.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.006346279166666684,
+                "max": 0.06388587500000005,
+                "median": 0.047794004166666675,
+                "min": 0.04482766666666671,
+                "n": 5,
+                "q25": 0.04731879999999998,
+                "q75": 0.053665079166666664
+              },
+              "run_p95s": {
+                "iqr": 0.009595599999999968,
+                "max": 0.12038149999999988,
+                "median": 0.0743509499999999,
+                "min": 0.0593,
+                "n": 5,
+                "q25": 0.06866924999999996,
+                "q75": 0.07826484999999993
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.004712970833333351,
+                "max": 0.06546495416666662,
+                "median": 0.045607283333333325,
+                "min": 0.043891616666666654,
+                "n": 5,
+                "q25": 0.04550832499999999,
+                "q75": 0.05022129583333334
+              },
+              "run_p95s": {
+                "iqr": 0.004495999999999889,
+                "max": 0.11536904999999999,
+                "median": 0.07517374999999983,
+                "min": 0.06573724999999994,
+                "n": 5,
+                "q25": 0.07175334999999992,
+                "q75": 0.07624934999999981
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.00134962916666663,
+                "max": 0.0015790791666665666,
+                "median": -0.0017115166666666556,
+                "min": -0.003443783333333325,
+                "n": 5,
+                "q25": -0.002285679166666686,
+                "q75": -0.0009360500000000563
+              },
+              "percent_change": {
+                "iqr": 2.6942476670168585,
+                "max": 2.4717187745594282,
+                "median": -3.6169908507118875,
+                "min": -6.417177402530294,
+                "n": 5,
+                "q25": -4.782355457592747,
+                "q75": -2.0881077905758882
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.00903484999999992,
+                "max": 0.0065044999999998715,
+                "median": -0.0020155000000001144,
+                "min": -0.005012449999999891,
+                "n": 5,
+                "q25": -0.0025975999999999777,
+                "q75": 0.006437249999999943
+              },
+              "percent_change": {
+                "iqr": 12.965917614350563,
+                "max": 10.8553962900505,
+                "median": -2.5752301320453808,
+                "min": -4.163804239023349,
+                "n": 5,
+                "q25": -3.493701156474771,
+                "q75": 9.472216457875792
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 24128,
+              "median": 24128,
+              "min": 24128,
+              "n": 5,
+              "q25": 24128.0,
+              "q75": 24128.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 23152,
+              "median": 23152,
+              "min": 23152,
+              "n": 5,
+              "q25": 23152.0,
+              "q75": 23152.0
+            }
+          }
+        },
+        "wrap-line-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.012499999999988631,
+              "max": 311.5,
+              "median": 311.5,
+              "min": 311.48333333333335,
+              "n": 5,
+              "q25": 311.4875,
+              "q75": 311.5
+            },
+            "candidate": {
+              "iqr": 0.024999999999977263,
+              "max": 273.7125,
+              "median": 273.69166666666666,
+              "min": 273.6375,
+              "n": 5,
+              "q25": 273.68333333333334,
+              "q75": 273.7083333333333
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 30720.0,
+                "median": 30720.0,
+                "min": 30720.0
+              },
+              "candidate": {
+                "max": 30720.0,
+                "median": 30720.0,
+                "min": 30720.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 30720.0,
+                "median": 30720.0,
+                "min": 30720.0
+              },
+              "candidate": {
+                "max": 30720.0,
+                "median": 30720.0,
+                "min": 30720.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 614522880.0,
+                "median": 614522880.0,
+                "min": 614522880.0
+              },
+              "candidate": {
+                "max": 614522880.0,
+                "median": 614522880.0,
+                "min": 614522880.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 614400000.0,
+                "median": 614400000.0,
+                "min": 614400000.0
+              },
+              "candidate": {
+                "max": 614400000.0,
+                "median": 614400000.0,
+                "min": 614400000.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              },
+              "candidate": {
+                "max": 3840.0,
+                "median": 3840.0,
+                "min": 3840.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 38400000.0,
+                "median": 38400000.0,
+                "min": 38400000.0
+              },
+              "candidate": {
+                "max": 38400000.0,
+                "median": 38400000.0,
+                "min": 38400000.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.2847475750000097,
+                "max": 10.768890066666668,
+                "median": 9.865713379166667,
+                "min": 9.104072420833337,
+                "n": 5,
+                "q25": 9.857234520833325,
+                "q75": 10.141982095833335
+              },
+              "run_p95s": {
+                "iqr": 0.10296139999999987,
+                "max": 14.680327,
+                "median": 14.022811699999998,
+                "min": 11.39467445,
+                "n": 5,
+                "q25": 13.98756375,
+                "q75": 14.09052515
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.4575524624999918,
+                "max": 10.596444458333337,
+                "median": 9.114603083333332,
+                "min": 8.893626312500002,
+                "n": 5,
+                "q25": 8.97429129166667,
+                "q75": 9.431843754166662
+              },
+              "run_p95s": {
+                "iqr": 1.362180450000002,
+                "max": 14.575652349999997,
+                "median": 11.6246263,
+                "min": 10.762599049999999,
+                "n": 5,
+                "q25": 11.010212199999994,
+                "q75": 12.372392649999997
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.5406641875000009,
+                "max": -0.1724456083333301,
+                "median": -0.7101383416666724,
+                "min": -0.8829432291666546,
+                "n": 5,
+                "q25": -0.7511102958333353,
+                "q75": -0.21044610833333444
+              },
+              "percent_change": {
+                "iqr": 5.301779797029383,
+                "max": -1.601331309594356,
+                "median": -7.001968007401837,
+                "min": -8.957311782534427,
+                "n": 5,
+                "q25": -7.613339927545915,
+                "q75": -2.3115601305165323
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 2.9756383000000017,
+                "max": 0.22995184999999907,
+                "median": -1.6504190500000018,
+                "min": -3.224964700000001,
+                "n": 5,
+                "q25": -3.080312950000005,
+                "q75": -0.10467465000000331
+              },
+              "percent_change": {
+                "iqr": 21.147854412091228,
+                "max": 2.018064237017314,
+                "median": -11.769530143516093,
+                "min": -23.0559428192061,
+                "n": 5,
+                "q25": -21.860881104207852,
+                "q75": -0.7130266921166251
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 1.3000000000029104,
+              "max": 83721.36666666667,
+              "median": 83721.36666666667,
+              "min": 83719.63333333333,
+              "n": 5,
+              "q25": 83720.06666666667,
+              "q75": 83721.36666666667
+            },
+            "candidate": {
+              "iqr": 2.599999999991269,
+              "max": 82836.4,
+              "median": 82834.23333333334,
+              "min": 82828.6,
+              "n": 5,
+              "q25": 82833.36666666667,
+              "q75": 82835.96666666666
+            }
+          }
+        },
+        "zoom-line-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.34166666666664014,
+              "max": 284.6041666666667,
+              "median": 284.3625,
+              "min": 284.025,
+              "n": 5,
+              "q25": 284.22083333333336,
+              "q75": 284.5625
+            },
+            "candidate": {
+              "iqr": 0.07500000000001705,
+              "max": 252.05,
+              "median": 251.8875,
+              "min": 251.00833333333333,
+              "n": 5,
+              "q25": 251.85416666666666,
+              "q75": 251.92916666666667
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              },
+              "candidate": {
+                "max": 240.0,
+                "median": 240.0,
+                "min": 240.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.snapshot.copied_bytes": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.query_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.auto_range.range_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.frame.gpu_buffer_allocation_count": {
+              "baseline": {
+                "max": 144.0,
+                "median": 144.0,
+                "min": 144.0
+              },
+              "candidate": {
+                "max": 144.0,
+                "median": 144.0,
+                "min": 144.0
+              }
+            },
+            "renderer.frame.upload.line_window_bytes": {
+              "baseline": {
+                "max": 169112832.0,
+                "median": 169112832.0,
+                "min": 169112832.0
+              },
+              "candidate": {
+                "max": 169112832.0,
+                "median": 169112832.0,
+                "min": 169112832.0
+              }
+            },
+            "renderer.frame.upload.line_window_count": {
+              "baseline": {
+                "max": 1920.0,
+                "median": 1920.0,
+                "min": 1920.0
+              },
+              "candidate": {
+                "max": 1920.0,
+                "median": 1920.0,
+                "min": 1920.0
+              }
+            },
+            "renderer.frame.upload.primary_bytes": {
+              "baseline": {
+                "max": 169051392.0,
+                "median": 169051392.0,
+                "min": 169051392.0
+              },
+              "candidate": {
+                "max": 169051392.0,
+                "median": 169051392.0,
+                "min": 169051392.0
+              }
+            },
+            "renderer.frame.upload.primary_count": {
+              "baseline": {
+                "max": 1920.0,
+                "median": 1920.0,
+                "min": 1920.0
+              },
+              "candidate": {
+                "max": 1920.0,
+                "median": 1920.0,
+                "min": 1920.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_count": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "renderer.series_window.monotonicity_scan_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.22328520833333276,
+                "max": 1.8826461958333334,
+                "median": 1.5489051958333326,
+                "min": 1.3494785333333326,
+                "n": 5,
+                "q25": 1.3660201583333342,
+                "q75": 1.589305366666667
+              },
+              "run_p95s": {
+                "iqr": 0.6961444500000007,
+                "max": 4.265059449999999,
+                "median": 2.4917775499999997,
+                "min": 2.2815101999999996,
+                "n": 5,
+                "q25": 2.3640065999999993,
+                "q75": 3.06015105
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.2316058708333335,
+                "max": 1.655567416666666,
+                "median": 1.4254603541666662,
+                "min": 1.334887720833332,
+                "n": 5,
+                "q25": 1.3613528208333336,
+                "q75": 1.5929586916666671
+              },
+              "run_p95s": {
+                "iqr": 0.5162306499999998,
+                "max": 3.4455547499999994,
+                "median": 2.4046753,
+                "min": 2.30637045,
+                "n": 5,
+                "q25": 2.3823597499999996,
+                "q75": 2.8985903999999993
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.04300672500000324,
+                "max": 0.10666222083333343,
+                "median": 0.0036533250000001516,
+                "min": -0.4571858416666672,
+                "n": 5,
+                "q25": -0.031132437500002164,
+                "q75": 0.01187428750000108
+              },
+              "percent_change": {
+                "iqr": 3.158978091500586,
+                "max": 6.886297568131505,
+                "median": 0.2298692923728307,
+                "min": -24.284214563443175,
+                "n": 5,
+                "q25": -2.2790613527977843,
+                "q75": 0.8799167387028017
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.2624102000000006,
+                "max": 0.9537771999999998,
+                "median": -0.05763614999999911,
+                "min": -1.860384149999999,
+                "n": 5,
+                "q25": -0.16156065000000064,
+                "q75": 0.10084954999999995
+              },
+              "percent_change": {
+                "iqr": 9.699797204727256,
+                "max": 38.27698022241191,
+                "median": -2.4380706043713674,
+                "min": -43.619184487569086,
+                "n": 5,
+                "q25": -5.2794991933486575,
+                "q75": 4.420298011378598
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 56.93333333331975,
+              "max": 134599.81666666668,
+              "median": 134552.51666666666,
+              "min": 134480.51666666666,
+              "n": 5,
+              "q25": 134536.48333333334,
+              "q75": 134593.41666666666
+            },
+            "candidate": {
+              "iqr": 12.66666666668607,
+              "max": 133839.91666666666,
+              "median": 133820.68333333332,
+              "min": 133666.18333333332,
+              "n": 5,
+              "q25": 133813.05,
+              "q75": 133825.71666666667
+            }
+          }
+        }
+      },
+      "created_at": "2026-11-04T00:14:44.454338+00:00",
+      "ended_at": "2026-11-04T00:16:08.670582+00:00",
+      "executables": {
+        "baseline": {
+          "bytes": 2058480,
+          "git_at_binary_location": null,
+          "path": "/workspace/scratch/09f16afbdc00/evidence/bin/vnm_plot_benchmark_baseline_v2",
+          "sha256": "a421c9d8832519110d6bc0eb2253916798eef0d30512f5359f46673c51f29f5d"
+        },
+        "candidate": {
+          "bytes": 2053392,
+          "git_at_binary_location": null,
+          "path": "/workspace/scratch/09f16afbdc00/evidence/bin/vnm_plot_benchmark_candidate_v2",
+          "sha256": "77cfcf554e536ae0adfb4575ae8e7cf89623aa13fa99003e7df5088b96b21c9d"
+        }
+      },
+      "frames": 240,
+      "host": {
+        "cpu_affinity": [
+          8
+        ],
+        "cpu_count": 9,
+        "cpu_model": "AMD EPYC 9V74 80-Core Processor",
+        "machine": "x86_64",
+        "platform": "Linux-6.18.57-x86_64-with-glibc2.39",
+        "python": "3.12.3",
+        "renderer_environment": {
+          "GALLIUM_DRIVER": null,
+          "LIBGL_ALWAYS_SOFTWARE": null,
+          "LP_NUM_THREADS": null,
+          "MESA_LOADER_DRIVER_OVERRIDE": null,
+          "QSG_RENDER_LOOP": null,
+          "QSG_RHI_BACKEND": null,
+          "QT_FONT_DPI": null,
+          "QT_QPA_PLATFORM": "offscreen",
+          "QT_SCALE_FACTOR": null,
+          "QT_SCREEN_SCALE_FACTORS": null,
+          "XDG_CACHE_HOME": null
+        }
+      },
+      "internal_profiling": true,
+      "repetitions": 5,
+      "warmup_frames": 30
+    },
+    "final-paired-outer": {
+      "cases": {
+        "dense-line-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 190,
+              "median": 190,
+              "min": 190,
+              "n": 9,
+              "q25": 190.0,
+              "q75": 190.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 152,
+              "median": 152,
+              "min": 152,
+              "n": 9,
+              "q25": 152.0,
+              "q75": 152.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              },
+              "candidate": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 800000.0,
+                "median": 800000.0,
+                "min": 800000.0
+              },
+              "candidate": {
+                "max": 800000.0,
+                "median": 800000.0,
+                "min": 800000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.0021608596000000577,
+                "max": 0.03925430399999992,
+                "median": 0.03214592600000009,
+                "min": 0.03048727520000013,
+                "n": 9,
+                "q25": 0.030680840800000005,
+                "q75": 0.03284170040000006
+              },
+              "run_p95s": {
+                "iqr": 0.008959500000000016,
+                "max": 0.054696500000000016,
+                "median": 0.04537455000000002,
+                "min": 0.04084300000000001,
+                "n": 9,
+                "q25": 0.042063,
+                "q75": 0.05102250000000002
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.0020335838000000404,
+                "max": 0.03351259920000004,
+                "median": 0.03015624340000003,
+                "min": 0.027689319000000025,
+                "n": 9,
+                "q25": 0.029348686800000103,
+                "q75": 0.031382270600000144
+              },
+              "run_p95s": {
+                "iqr": 0.0031549499999999966,
+                "max": 0.0556945,
+                "median": 0.0420245,
+                "min": 0.030893500000000063,
+                "n": 9,
+                "q25": 0.039980550000000004,
+                "q75": 0.0431355
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.0018372673999998423,
+                "max": 0.0015003097999999465,
+                "median": -0.002173139400000062,
+                "min": -0.009098060599999892,
+                "n": 9,
+                "q25": -0.00299152179999998,
+                "q75": -0.0011542544000001376
+              },
+              "percent_change": {
+                "iqr": 5.239999078393264,
+                "max": 4.921101640463887,
+                "median": -6.6170124370297785,
+                "min": -23.177230705707863,
+                "n": 9,
+                "q25": -9.012329613124347,
+                "q75": -3.772330534731083
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.009105499999999964,
+                "max": 0.01485149999999999,
+                "median": -0.003708450000000009,
+                "min": -0.012672000000000017,
+                "n": 9,
+                "q25": -0.010009999999999946,
+                "q75": -0.0009044999999999817
+              },
+              "percent_change": {
+                "iqr": 20.435323115564298,
+                "max": 36.362412163651015,
+                "median": -8.488292247476503,
+                "min": -24.47223342745717,
+                "n": 9,
+                "q25": -22.585669025271127,
+                "q75": -2.15034590970683
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 13952,
+              "median": 13952,
+              "min": 13952,
+              "n": 9,
+              "q25": 13952.0,
+              "q75": 13952.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 13056,
+              "median": 13056,
+              "min": 13056,
+              "n": 9,
+              "q25": 13056.0,
+              "q75": 13056.0
+            }
+          }
+        },
+        "warm-area-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 190,
+              "median": 190,
+              "min": 190,
+              "n": 9,
+              "q25": 190.0,
+              "q75": 190.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 152,
+              "median": 152,
+              "min": 152,
+              "n": 9,
+              "q25": 152.0,
+              "q75": 152.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              },
+              "candidate": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.0005606577999999578,
+                "max": 0.043987643599999945,
+                "median": 0.030850828800000032,
+                "min": 0.029742129599999986,
+                "n": 9,
+                "q25": 0.030786361399999993,
+                "q75": 0.03134701919999995
+              },
+              "run_p95s": {
+                "iqr": 0.003215050000000004,
+                "max": 0.0663005,
+                "median": 0.04257800000000002,
+                "min": 0.03016750000000001,
+                "n": 9,
+                "q25": 0.041092449999999996,
+                "q75": 0.0443075
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.0021129461999999134,
+                "max": 0.03236644079999998,
+                "median": 0.028631657599999936,
+                "min": 0.02762359840000002,
+                "n": 9,
+                "q25": 0.028027161200000116,
+                "q75": 0.03014010740000003
+              },
+              "run_p95s": {
+                "iqr": 0.007272999999999974,
+                "max": 0.046040950000000004,
+                "median": 0.03915700000000003,
+                "min": 0.03136950000000001,
+                "n": 9,
+                "q25": 0.03394950000000003,
+                "q75": 0.0412225
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.00314682540000007,
+                "max": 0.0015156119999999475,
+                "median": -0.002213190000000153,
+                "min": -0.016213008799999897,
+                "n": 9,
+                "q25": -0.003205454799999969,
+                "q75": -5.86293999998988e-05
+              },
+              "percent_change": {
+                "iqr": 9.79116858637964,
+                "max": 4.912710805357512,
+                "median": -7.175234025147681,
+                "min": -36.858098031875286,
+                "n": 9,
+                "q25": -9.981608110031493,
+                "q75": -0.19043952365185302
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.008464000000000006,
+                "max": 0.004888950000000003,
+                "median": -0.0020219999999999613,
+                "min": -0.03493099999999999,
+                "n": 9,
+                "q25": -0.0073825500000000085,
+                "q75": 0.0010814499999999977
+              },
+              "percent_change": {
+                "iqr": 18.532552748399755,
+                "max": 12.536670257727733,
+                "median": -4.563561473791033,
+                "min": -52.6858771804134,
+                "n": 9,
+                "q25": -15.587150743037048,
+                "q75": 2.9454020053627072
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 13952,
+              "median": 13952,
+              "min": 13952,
+              "n": 9,
+              "q25": 13952.0,
+              "q75": 13952.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 13056,
+              "median": 13056,
+              "min": 13056,
+              "n": 9,
+              "q25": 13056.0,
+              "q75": 13056.0
+            }
+          }
+        },
+        "warm-dots-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 186,
+              "median": 186,
+              "min": 186,
+              "n": 9,
+              "q25": 186.0,
+              "q75": 186.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 142,
+              "median": 142,
+              "min": 142,
+              "n": 9,
+              "q25": 142.0,
+              "q75": 142.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              },
+              "candidate": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.0018262517999999492,
+                "max": 0.042147341200000125,
+                "median": 0.03351848379999996,
+                "min": 0.03175616459999984,
+                "n": 9,
+                "q25": 0.032853515599999876,
+                "q75": 0.034679767399999825
+              },
+              "run_p95s": {
+                "iqr": 0.005313550000000021,
+                "max": 0.08611055000000002,
+                "median": 0.0477335,
+                "min": 0.042364500000000006,
+                "n": 9,
+                "q25": 0.044147,
+                "q75": 0.04946055000000002
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.00291018839999984,
+                "max": 0.04322156780000007,
+                "median": 0.03257873079999999,
+                "min": 0.03010796419999997,
+                "n": 9,
+                "q25": 0.03137805080000003,
+                "q75": 0.03428823919999987
+              },
+              "run_p95s": {
+                "iqr": 0.005517000000000036,
+                "max": 0.08539055000000001,
+                "median": 0.04286455,
+                "min": 0.04033800000000003,
+                "n": 9,
+                "q25": 0.041503,
+                "q75": 0.047020000000000034
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.0021513186000001044,
+                "max": 0.008541800400000243,
+                "median": -0.0014512739999999191,
+                "min": -0.009115819000000185,
+                "n": 9,
+                "q25": -0.0024261033999999904,
+                "q75": -0.0002747847999998859
+              },
+              "percent_change": {
+                "iqr": 5.718723371846934,
+                "max": 24.630500837789036,
+                "median": -4.395718374262724,
+                "min": -21.628455652144808,
+                "n": 9,
+                "q25": -6.555117270586608,
+                "q75": -0.8363938987396735
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.004016949999999998,
+                "max": -0.0004354499999998998,
+                "median": -0.0020264999999999797,
+                "min": -0.019122399999999984,
+                "n": 9,
+                "q25": -0.005038500000000008,
+                "q75": -0.00102155000000001
+              },
+              "percent_change": {
+                "iqr": 8.53839593115404,
+                "max": -0.8361344806182447,
+                "median": -4.7834861735650875,
+                "min": -29.50124924886932,
+                "n": 9,
+                "q25": -10.940655331900217,
+                "q75": -2.402259400746176
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 14464,
+              "median": 14464,
+              "min": 14464,
+              "n": 9,
+              "q25": 14464.0,
+              "q75": 14464.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 13424,
+              "median": 13424,
+              "min": 13424,
+              "n": 9,
+              "q25": 13424.0,
+              "q75": 13424.0
+            }
+          }
+        },
+        "warm-line-1": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 99,
+              "median": 99,
+              "min": 99,
+              "n": 9,
+              "q25": 99.0,
+              "q75": 99.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 61,
+              "median": 61,
+              "min": 61,
+              "n": 9,
+              "q25": 61.0,
+              "q75": 61.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              },
+              "candidate": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 10000.0,
+                "median": 10000.0,
+                "min": 10000.0
+              },
+              "candidate": {
+                "max": 10000.0,
+                "median": 10000.0,
+                "min": 10000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.006024057600000042,
+                "max": 0.033657033999999905,
+                "median": 0.02261256460000001,
+                "min": 0.020846536600000017,
+                "n": 9,
+                "q25": 0.021542968999999905,
+                "q75": 0.027567026599999947
+              },
+              "run_p95s": {
+                "iqr": 0.008918499999999979,
+                "max": 0.04901350000000008,
+                "median": 0.025814500000000018,
+                "min": 0.021332500000000004,
+                "n": 9,
+                "q25": 0.024186500000000038,
+                "q75": 0.033105000000000016
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.0009412875999999758,
+                "max": 0.02852573339999999,
+                "median": 0.021475740800000063,
+                "min": 0.020316559800000005,
+                "n": 9,
+                "q25": 0.020968523600000025,
+                "q75": 0.0219098112
+              },
+              "run_p95s": {
+                "iqr": 0.009668000000000013,
+                "max": 0.03328300000000001,
+                "median": 0.028177000000000015,
+                "min": 0.021153000000000005,
+                "n": 9,
+                "q25": 0.02320700000000001,
+                "q75": 0.03287500000000002
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.0004094036000001078,
+                "max": 0.0006304583999998878,
+                "median": -0.0008476186000000961,
+                "min": -0.011267373199999813,
+                "n": 9,
+                "q25": -0.001028390800000046,
+                "q75": -0.0006189871999999381
+              },
+              "percent_change": {
+                "iqr": 1.7079115092910162,
+                "max": 2.2600902841068526,
+                "median": -3.7484408115304846,
+                "min": -33.47702355471919,
+                "n": 9,
+                "q25": -4.581179349020726,
+                "q75": -2.8732678397297096
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.001806050000000014,
+                "max": 0.008745000000000003,
+                "median": -0.0002299999999999941,
+                "min": -0.01573050000000007,
+                "n": 9,
+                "q25": -0.000979500000000029,
+                "q75": 0.0008265499999999849
+              },
+              "percent_change": {
+                "iqr": 7.251662498703427,
+                "max": 35.944018578269166,
+                "median": -0.6947590998338415,
+                "min": -32.094218939679976,
+                "n": 9,
+                "q25": -4.049779835858958,
+                "q75": 3.2018826628444685
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 7400,
+              "median": 7400,
+              "min": 7400,
+              "n": 9,
+              "q25": 7400.0,
+              "q75": 7400.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 6504,
+              "median": 6504,
+              "min": 6504,
+              "n": 9,
+              "q25": 6504.0,
+              "q75": 6504.0
+            }
+          }
+        },
+        "warm-line-32": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 502,
+              "median": 502,
+              "min": 502,
+              "n": 9,
+              "q25": 502.0,
+              "q75": 502.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 464,
+              "median": 464,
+              "min": 464,
+              "n": 9,
+              "q25": 464.0,
+              "q75": 464.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              },
+              "candidate": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 320000.0,
+                "median": 320000.0,
+                "min": 320000.0
+              },
+              "candidate": {
+                "max": 320000.0,
+                "median": 320000.0,
+                "min": 320000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.009084232199999681,
+                "max": 0.0855989530000003,
+                "median": 0.06403848200000017,
+                "min": 0.058641479399999835,
+                "n": 9,
+                "q25": 0.06082180700000049,
+                "q75": 0.06990603920000017
+              },
+              "run_p95s": {
+                "iqr": 0.035349050000000035,
+                "max": 0.15991805000000003,
+                "median": 0.10291650000000001,
+                "min": 0.07304,
+                "n": 9,
+                "q25": 0.07578795,
+                "q75": 0.11113700000000004
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.005588497199999973,
+                "max": 0.07257722679999995,
+                "median": 0.06342248900000004,
+                "min": 0.056060835399999905,
+                "n": 9,
+                "q25": 0.057954494599999906,
+                "q75": 0.06354299179999988
+              },
+              "run_p95s": {
+                "iqr": 0.04078355000000007,
+                "max": 0.14304655000000005,
+                "median": 0.10821550000000002,
+                "min": 0.07137,
+                "n": 9,
+                "q25": 0.07958400000000002,
+                "q75": 0.12036755000000009
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.008722200599999959,
+                "max": 0.002600681999999549,
+                "median": -0.0023157999999998333,
+                "min": -0.013021726200000347,
+                "n": 9,
+                "q25": -0.009292443000000282,
+                "q75": -0.0005702424000003231
+              },
+              "percent_change": {
+                "iqr": 13.328317978427616,
+                "max": 4.2759038711222885,
+                "median": -3.949081816649802,
+                "min": -16.461420975486153,
+                "n": 9,
+                "q25": -14.218786306518716,
+                "q75": -0.8904683280910985
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.02691750000000001,
+                "max": 0.029311500000000018,
+                "median": -1.9950000000032442e-05,
+                "min": -0.04332805000000009,
+                "n": 9,
+                "q25": -0.016871499999999984,
+                "q75": 0.010046000000000027
+              },
+              "percent_change": {
+                "iqr": 19.656199586834642,
+                "max": 31.819341391794275,
+                "median": -0.027261360608399343,
+                "min": -28.59115415997583,
+                "n": 9,
+                "q25": -10.550091124797966,
+                "q75": 9.106108462036676
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 36416,
+              "median": 36416,
+              "min": 36416,
+              "n": 9,
+              "q25": 36416.0,
+              "q75": 36416.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 35520,
+              "median": 35520,
+              "min": 35520,
+              "n": 9,
+              "q25": 35520.0,
+              "q75": 35520.0
+            }
+          }
+        },
+        "warm-line-8": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 190,
+              "median": 190,
+              "min": 190,
+              "n": 9,
+              "q25": 190.0,
+              "q75": 190.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 152,
+              "median": 152,
+              "min": 152,
+              "n": 9,
+              "q25": 152.0,
+              "q75": 152.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              },
+              "candidate": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.002139831999999918,
+                "max": 0.035728769000000146,
+                "median": 0.031379987999999984,
+                "min": 0.029703203800000102,
+                "n": 9,
+                "q25": 0.030242084600000108,
+                "q75": 0.032381916600000026
+              },
+              "run_p95s": {
+                "iqr": 0.014303050000000005,
+                "max": 0.06138705000000002,
+                "median": 0.04235550000000001,
+                "min": 0.038096550000000104,
+                "n": 9,
+                "q25": 0.040622,
+                "q75": 0.05492505
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.0039878742000000605,
+                "max": 0.03375254980000007,
+                "median": 0.029834080000000148,
+                "min": 0.027289051599999982,
+                "n": 9,
+                "q25": 0.02770758799999997,
+                "q75": 0.03169546220000003
+              },
+              "run_p95s": {
+                "iqr": 0.02170550000000001,
+                "max": 0.05972300000000001,
+                "median": 0.04408050000000001,
+                "min": 0.029076000000000005,
+                "n": 9,
+                "q25": 0.03171000000000001,
+                "q75": 0.05341550000000002
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.004090141600000097,
+                "max": 0.0014533775999999235,
+                "median": -0.002134070600000204,
+                "min": -0.005894688999999998,
+                "n": 9,
+                "q25": -0.0037721708000000576,
+                "q75": 0.0003179708000000392
+              },
+              "percent_change": {
+                "iqr": 12.99613696275027,
+                "max": 4.805811567632201,
+                "median": -7.184647872901162,
+                "min": -16.498438555215756,
+                "n": 9,
+                "q25": -11.982845306934353,
+                "q75": 1.0132916558159177
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.017569450000000014,
+                "max": 0.015318949999999915,
+                "median": -0.007815450000000009,
+                "min": -0.016743999999999995,
+                "n": 9,
+                "q25": -0.012771500000000005,
+                "q75": 0.004797950000000009
+              },
+              "percent_change": {
+                "iqr": 35.12953423569169,
+                "max": 40.210858988543244,
+                "median": -20.504919323101156,
+                "min": -30.519146902443406,
+                "n": 9,
+                "q25": -26.394084745886936,
+                "q75": 8.735449489804758
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 13952,
+              "median": 13952,
+              "min": 13952,
+              "n": 9,
+              "q25": 13952.0,
+              "q75": 13952.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 13056,
+              "median": 13056,
+              "min": 13056,
+              "n": 9,
+              "q25": 13056.0,
+              "q75": 13056.0
+            }
+          }
+        },
+        "warm-line-8-no-text": {
+          "allocations_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 114,
+              "median": 114,
+              "min": 114,
+              "n": 9,
+              "q25": 114.0,
+              "q75": 114.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 114,
+              "median": 114,
+              "min": 114,
+              "n": 9,
+              "q25": 114.0,
+              "q75": 114.0
+            }
+          },
+          "counter_totals": {
+            "benchmark.frame.output_count": {
+              "baseline": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              },
+              "candidate": {
+                "max": 5000.0,
+                "median": 5000.0,
+                "min": 5000.0
+              }
+            },
+            "benchmark.ring.occupancy": {
+              "baseline": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              },
+              "candidate": {
+                "max": 80000.0,
+                "median": 80000.0,
+                "min": 80000.0
+              }
+            },
+            "benchmark.ring.overwritten_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            },
+            "benchmark.ring.published_samples": {
+              "baseline": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              },
+              "candidate": {
+                "max": 0.0,
+                "median": 0.0,
+                "min": 0.0
+              }
+            }
+          },
+          "frame_wall_ms": {
+            "baseline": {
+              "run_means": {
+                "iqr": 0.0011896819999999888,
+                "max": 0.018945141200000015,
+                "median": 0.01169405580000001,
+                "min": 0.010902060200000063,
+                "n": 9,
+                "q25": 0.011409149400000033,
+                "q75": 0.012598831400000022
+              },
+              "run_p95s": {
+                "iqr": 0.0026355000000000076,
+                "max": 0.016815,
+                "median": 0.011778,
+                "min": 0.010746,
+                "n": 9,
+                "q25": 0.011177,
+                "q75": 0.013812500000000007
+              }
+            },
+            "candidate": {
+              "run_means": {
+                "iqr": 0.0005843335999999883,
+                "max": 0.015331708599999971,
+                "median": 0.011645871399999988,
+                "min": 0.011213593400000029,
+                "n": 9,
+                "q25": 0.011557136999999997,
+                "q75": 0.012141470599999985
+              },
+              "run_p95s": {
+                "iqr": 0.0038249499999999954,
+                "max": 0.01614405,
+                "median": 0.011537500000000001,
+                "min": 0.010977,
+                "n": 9,
+                "q25": 0.011328500000000005,
+                "q75": 0.01515345
+              }
+            },
+            "paired_means": {
+              "absolute_change": {
+                "iqr": 0.0012651410000000442,
+                "max": 0.0027328771999999488,
+                "median": 6.573959999999282e-05,
+                "min": -0.007209315599999979,
+                "n": 9,
+                "q25": -0.0006637944000000527,
+                "q75": 0.0006013465999999915
+              },
+              "percent_change": {
+                "iqr": 10.881312087698758,
+                "max": 21.691513389090545,
+                "median": 0.5762007113343071,
+                "min": -38.05363878734234,
+                "n": 9,
+                "q25": -5.3924648384853,
+                "q75": 5.488847249213458
+              }
+            },
+            "paired_p95s": {
+              "absolute_change": {
+                "iqr": 0.0009904999999999949,
+                "max": 0.004926549999999998,
+                "median": 0.000330449999999996,
+                "min": -0.004436000000000001,
+                "n": 9,
+                "q25": -0.00044949999999999504,
+                "q75": 0.0005409999999999998
+              },
+              "percent_change": {
+                "iqr": 8.850868842049875,
+                "max": 43.91843102295518,
+                "median": 2.171941240264186,
+                "min": -26.38120725542671,
+                "n": 9,
+                "q25": -3.8164374257089073,
+                "q75": 5.034431416340968
+              }
+            }
+          },
+          "requested_allocation_bytes_per_frame": {
+            "baseline": {
+              "iqr": 0.0,
+              "max": 9312,
+              "median": 9312,
+              "min": 9312,
+              "n": 9,
+              "q25": 9312.0,
+              "q75": 9312.0
+            },
+            "candidate": {
+              "iqr": 0.0,
+              "max": 9312,
+              "median": 9312,
+              "min": 9312,
+              "n": 9,
+              "q25": 9312.0,
+              "q75": 9312.0
+            }
+          }
+        }
+      },
+      "created_at": "2026-11-04T00:13:34.775134+00:00",
+      "ended_at": "2026-11-04T00:14:19.373457+00:00",
+      "executables": {
+        "baseline": {
+          "bytes": 2058480,
+          "git_at_binary_location": null,
+          "path": "/workspace/scratch/09f16afbdc00/evidence/bin/vnm_plot_benchmark_baseline_v2",
+          "sha256": "a421c9d8832519110d6bc0eb2253916798eef0d30512f5359f46673c51f29f5d"
+        },
+        "candidate": {
+          "bytes": 2053392,
+          "git_at_binary_location": null,
+          "path": "/workspace/scratch/09f16afbdc00/evidence/bin/vnm_plot_benchmark_candidate_v2",
+          "sha256": "77cfcf554e536ae0adfb4575ae8e7cf89623aa13fa99003e7df5088b96b21c9d"
+        }
+      },
+      "frames": 5000,
+      "host": {
+        "cpu_affinity": [
+          8
+        ],
+        "cpu_count": 9,
+        "cpu_model": "AMD EPYC 9V74 80-Core Processor",
+        "machine": "x86_64",
+        "platform": "Linux-6.18.57-x86_64-with-glibc2.39",
+        "python": "3.12.3",
+        "renderer_environment": {
+          "GALLIUM_DRIVER": null,
+          "LIBGL_ALWAYS_SOFTWARE": null,
+          "LP_NUM_THREADS": null,
+          "MESA_LOADER_DRIVER_OVERRIDE": null,
+          "QSG_RENDER_LOOP": null,
+          "QSG_RHI_BACKEND": null,
+          "QT_FONT_DPI": null,
+          "QT_QPA_PLATFORM": "offscreen",
+          "QT_SCALE_FACTOR": null,
+          "QT_SCREEN_SCALE_FACTORS": null,
+          "XDG_CACHE_HOME": null
+        }
+      },
+      "internal_profiling": false,
+      "repetitions": 9,
+      "warmup_frames": 100
+    }
+  },
+  "provenance": {
+    "baseline_binary_sha256": "a421c9d8832519110d6bc0eb2253916798eef0d30512f5359f46673c51f29f5d",
+    "baseline_cpp_sources_clean": true,
+    "baseline_source_revisions": {
+      "glm": "8d1fd52e5ab5590e2c81768ace50c72bae28f2ed",
+      "msdfgen": "1874bcf7d9624ccc85b4bc9a85d78116f690f35b",
+      "vnm_cmake": "66d5ee14f4f69c952daa58a95a4759ad77a636f4",
+      "vnm_fonts": "c9adbd52cd3bc983d313993436381522e15864e1",
+      "vnm_msdf_text": "3e89f1358c88b46f7c68b99dd9bf76003b5a3db3",
+      "vnm_plot": "88d459dbbad9cff1a292b3ffa87be97970d371e6"
+    },
+    "build_type": "Release",
+    "candidate_binary_sha256": "77cfcf554e536ae0adfb4575ae8e7cf89623aa13fa99003e7df5088b96b21c9d",
+    "candidate_source_revision": "70638b6e65103b657daaa16e00bcea7fe8daf800",
+    "compiler": "GCC 13.3.0",
+    "cxx_release_flags": "-O3 -DNDEBUG",
+    "freetype_actual": {
+      "source": "SDK support/usr package; cloned 2.14.3 checkout was not selected by CMake",
+      "version": "2.13.2"
+    },
+    "measurement_backend": "QRhi Null; no rasterization or GPU measurement",
+    "qt": "6.12.0",
+    "sdk_archive_sha256": "56100ede7b00bd7faf06a7b64c57b94106f63e3ba1b77c0bbdf5d61d7ca220c2",
+    "suite_command_pin_note": "The same final Python runner explicitly passed volatility=0.02, line width=1.5, dot size=1.0, 1200x720 to both compiled binaries.",
+    "timing_cpu_affinity": [
+      8
+    ],
+    "unused_prepared_sources": {
+      "freetype": {
+        "reason": "Checkout was prepared but not selected by CMake; SDK FreeType 2.13.2 was used.",
+        "revision": "0a0221a1347e2f1e07c395263540026e9a0aa7c7"
+      }
+    }
+  },
+  "schema_version": 1,
+  "status": "Allocation improvement demonstrated; conservative timing regression unresolved; native rendering unverified."
+}
diff --git a/benchmark/tools/run_suite.py b/benchmark/tools/run_suite.py
index ba726926..9b362895 100644
--- a/benchmark/tools/run_suite.py
+++ b/benchmark/tools/run_suite.py
@@ -70,6 +70,7 @@ def rate(self) -> float:
     Case("wrap-line-8", append=16, wrap=True),
     Case("warm-line-8-no-text", text=False),
     Case("warm-line-8-conservative", stable_access=False),
+    Case("warm-line-8-conservative-no-text", stable_access=False, text=False),
 )
 
 METRICS = (
@@ -183,6 +184,9 @@ def expected_metadata(case: Case, args: argparse.Namespace) -> dict[str, str]:
         "scenario": case.name,
         "framebuffer": "1200x720",
         "sample_count": "4",
+        "volatility": "0.020000",
+        "line_width_px": "1.500000",
+        "point_diameter_px": "1.000000",
     }
 
 
@@ -301,6 +305,8 @@ def command_for(executable: Path, case: Case, args: argparse.Namespace, director
         "--static", "--seed", "42", "--data-type", case.data_type, "--render-style", case.style,
         "--series-count", str(case.series), "--static-samples", str(case.samples),
         "--ring-size", str(case.capacity(args.frames)), "--rate", str(case.rate),
+        "--volatility", "0.02", "--line-px", "1.5", "--point-px", "1.0",
+        "--width", "1200", "--height", "720",
         "--view-motion", case.motion, "--append-per-frame", str(case.append),
         "--warmup-frames", str(args.warmup_frames), "--frames", str(args.frames),
         "--finish", "--quiet", "--scenario", case.name, "--output-dir", str(directory),

From 4f491b7de421a7f10fadbc2913d8d3e90911cd76 Mon Sep 17 00:00:00 2001
From: Ioannis Makris <imak@imak.gr>
Date: Wed, 4 Nov 2026 02:38:33 +0100
Subject: [PATCH 3/5] Record balanced controls and the reproduced conservative
 timing penalty [skip ci]

Preserve 80 fixed initial follow-up observations, including identical-binary controls. Conservative no-text is slower in all eight retained-binary pairs (+5.45% median), while its identical-binary control is +0.71% with mixed signs.

Record the measured boundary defect and the native-display blocker before the bounded same-executable diagnostic. Production optimization remains separate.
---
 .../results/2026-11-04-followup/README.md     |  106 +
 .../2026-11-04-followup/measurements.json     | 5938 +++++++++++++++++
 2 files changed, 6044 insertions(+)
 create mode 100644 benchmark/results/2026-11-04-followup/README.md
 create mode 100644 benchmark/results/2026-11-04-followup/measurements.json

diff --git a/benchmark/results/2026-11-04-followup/README.md b/benchmark/results/2026-11-04-followup/README.md
new file mode 100644
index 00000000..2183fe40
--- /dev/null
+++ b/benchmark/results/2026-11-04-followup/README.md
@@ -0,0 +1,106 @@
+# Benchmark continuation — 4 November 2026
+
+## Published checkpoint
+
+This follows the original benchmark report in `../2026-11-04-null/README.md`.
+The original measurements and source remain intact. The production label-membership
+experiment remains separate from the benchmark foundation.
+
+The retained-binary comparison reproduces the conservative no-text slowdown:
+**all eight paired runs are slower, with a +5.45% median paired change**.
+The identical-binary control has a +0.71% median change on that workload, with
+mixed signs. This supports investigating a difference between these particular
+binaries; it does not identify the cause or qualify the production experiment.
+
+The stable no-text identical-binary comparison has a +5.72% median change,
+showing that small changes in this very short workload are unresolved on this host.
+No general speedup is inferred from those timings.
+
+## Fixed initial experiment
+
+Before running, `initial-plan.json` specified eight alternating A/B and B/A pairs,
+100 warmup frames and 1,000 measured frames per process, CPU 8 affinity, explicit
+QRhi Null, and reduced internal profiling. There were 32 A/A and 48 A/B processes.
+All 80 invocations completed and passed the existing workload-v2 validator.
+No repetitions were discarded or added after seeing the outcome.
+
+The A/A labels refer to the same baseline executable; they do not represent
+changed code. Mean columns below are medians of per-process means. Changes are
+medians of within-pair percentages; min–max is descriptive spread, not a confidence
+interval. Positive means more time. IQRs, per-process metrics and exact order are
+retained in `measurements.json`.
+
+| Experiment | Case | Baseline mean ms | Candidate mean ms | Paired change | Paired min–max | Slower pairs |
+|---|---|---:|---:|---:|---:|---:|
+| retained-aa | `warm-line-8-conservative-no-text` | 2.6358 | 2.6464 | +0.71% | -2.20 to +8.47% | 5/8 |
+| retained-aa | `warm-line-8-no-text` | 0.0111 | 0.0117 | +5.72% | -2.18 to +21.36% | 5/8 |
+| retained-ab | `warm-line-8-conservative` | 2.7276 | 2.9174 | +7.25% | -13.17 to +16.16% | 7/8 |
+| retained-ab | `warm-line-8-conservative-no-text` | 2.7849 | 2.8971 | +5.45% | +0.49 to +17.45% | 8/8 |
+| retained-ab | `warm-line-8-no-text` | 0.0115 | 0.0109 | -2.36% | -14.40 to +0.16% | 1/8 |
+
+The conservative text case retains the exact allocation reduction, 206 to 168
+allocations/frame. Both conservative no-text variants retain 130 allocations/frame;
+both stable no-text variants retain 114. Timing and allocation conclusions are
+kept separate.
+
+## Inputs and measurement boundary
+
+- Baseline executable SHA-256: `a421c9d8832519110d6bc0eb2253916798eef0d30512f5359f46673c51f29f5d`.
+- Candidate executable SHA-256: `77cfcf554e536ae0adfb4575ae8e7cf89623aa13fa99003e7df5088b96b21c9d`.
+- Original compiled revisions: baseline `88d459dbbad9cff1a292b3ffa87be97970d371e6`, candidate `70638b6e65103b657daaa16e00bcea7fe8daf800`.
+- Runner: foundation revision `a15293f39b52bbee54e129d59e6739e74a2970e6`.
+- Qt 6.12, GCC 13.3 Release, original dependencies and settings; executable hashes
+  were checked before use. Owned dependency default heads still match the retained
+  inputs when checked at continuation start.
+
+These are QRhi Null CPU-preparation wall times and render-thread C++ allocation
+traffic. They do not establish hardware GPU cost, application FPS, presentation
+latency or pixel equivalence. The short settled control is particularly sensitive
+to observed host variation. Internal profiling is reduced, not zero-overhead.
+
+## Concrete benchmark defect found
+
+The workload-v2 `--frame-timing-only` path still emits `renderer.frame.finish`,
+reads the preparation profiler through its mutex, and stores submission/finish
+observations before capturing the total-frame timestamp. This violates the stated
+absence of internal renderer scopes and includes avoidable measurement bookkeeping
+inside the frame total. Existing tests check only the exact `renderer.frame` scope
+and miss the finish scope.
+
+A bounded benchmark-only correction is being prepared: guard the remaining
+internal profiler work, record durations locally, stop the timing/allocation
+boundary before storing observations, and reject every `renderer.` scope or
+observation in frame-only validation. The workload contract will advance to v3,
+so v2 and v3 timings cannot silently be mixed. The v2 evidence above remains
+historical and is not relabeled after the correction.
+
+This bookkeeping discrepancy is far too small to explain the millisecond-scale
+conservative slowdown. It is an independent measurement-quality issue.
+
+## Native-rendering limit
+
+One fresh SDK Xvfb startup attempt exited 1 because local/unix sockets could not
+be opened. A minimal AF_UNIX capability check returned EPERM. The display process
+is finished. The previous EGL and Vulkan platform-initialization limitations remain
+recorded; no permission or syscall workaround was attempted.
+
+The maintained `FontRendererDrawRanges` and `SampleUploadReuse` raster/readback
+gates still require a supported native display. They have not passed in this
+continuation. Null is not substituted into those raster gates.
+
+## Next bounded diagnostic
+
+Read-only disassembly inspection finds the same range-scan, sample-reader,
+callback and frame-renderer instructions after relocation normalization, at
+different code addresses. The additional label-state flag fits the existing map
+node allocation size. The changed label algorithm is skipped with text disabled.
+This supports code placement as a hypothesis, not a proven cache mechanism.
+
+One diagnostic executable will contain both exact label implementations, selected
+before measured work. Keeping a single executable holds code placement constant
+while varying the label algorithm. The no-text control must not consult the switch.
+Its source and switch will remain diagnostic-only. The corrected benchmark harness
+will be used on both modes; source, binary and mode identities will be retained.
+
+The production experiment remains unpromoted while this question and native
+rendering qualification are open.
diff --git a/benchmark/results/2026-11-04-followup/measurements.json b/benchmark/results/2026-11-04-followup/measurements.json
new file mode 100644
index 00000000..0770b260
--- /dev/null
+++ b/benchmark/results/2026-11-04-followup/measurements.json
@@ -0,0 +1,5938 @@
+{
+  "experiments": {
+    "retained-aa": {
+      "created_at": "2026-11-04T01:32:16.120516+00:00",
+      "ended_at": "2026-11-04T01:33:05.699474+00:00",
+      "executables": {
+        "baseline": {
+          "bytes": 2058480,
+          "git_at_binary_location": null,
+          "path": "/workspace/scratch/2a7852710aa2/benchmark-followup/bin/baseline",
+          "sha256": "a421c9d8832519110d6bc0eb2253916798eef0d30512f5359f46673c51f29f5d"
+        },
+        "candidate": {
+          "bytes": 2058480,
+          "git_at_binary_location": null,
+          "path": "/workspace/scratch/2a7852710aa2/benchmark-followup/bin/baseline",
+          "sha256": "a421c9d8832519110d6bc0eb2253916798eef0d30512f5359f46673c51f29f5d"
+        }
+      },
+      "frames": 1000,
+      "host": {
+        "cpu_affinity": [
+          8
+        ],
+        "cpu_count": 9,
+        "cpu_model": "AMD EPYC 9V74 80-Core Processor",
+        "machine": "x86_64",
+        "platform": "Linux-6.18.57-x86_64-with-glibc2.39",
+        "python": "3.12.3",
+        "renderer_environment": {
+          "GALLIUM_DRIVER": null,
+          "LIBGL_ALWAYS_SOFTWARE": null,
+          "LP_NUM_THREADS": null,
+          "MESA_LOADER_DRIVER_OVERRIDE": null,
+          "QSG_RENDER_LOOP": null,
+          "QSG_RHI_BACKEND": null,
+          "QT_FONT_DPI": null,
+          "QT_QPA_PLATFORM": "offscreen",
+          "QT_SCALE_FACTOR": null,
+          "QT_SCREEN_SCALE_FACTORS": null,
+          "XDG_CACHE_HOME": null
+        }
+      },
+      "repetitions": 8,
+      "run_order": [
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 0,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 0,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 0,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 0,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 1,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 1,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 1,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 1,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 2,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 2,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 2,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 2,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 3,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 3,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 3,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 3,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 4,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 4,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 4,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 4,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 5,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 5,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 5,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 5,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 6,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 6,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 6,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 6,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 7,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 7,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 7,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 7,
+          "variant": "baseline"
+        }
+      ],
+      "runs": [
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4433999999999556e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010701986000000012,
+              "p95": 0.010958449999999998
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.010974169000000004,
+              "p95": 0.011327499999999999
+            }
+          },
+          "raw_report": "warm-line-8-no-text/01-baseline/inspector_benchmark_20261104_013216_181_SIM_Bars.json",
+          "repetition": 0,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4162999999999575e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.011220507000000005,
+              "p95": 0.011137999999999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.01149280899999999,
+              "p95": 0.011429049999999998
+            }
+          },
+          "raw_report": "warm-line-8-no-text/01-candidate/inspector_benchmark_20261104_013216_245_SIM_Bars.json",
+          "repetition": 0,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.60200000000001e-05,
+              "p95": 0.00015
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.609298536000002,
+              "p95": 3.0382486
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.610282876999999,
+              "p95": 3.0399986500000002
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/01-baseline/inspector_benchmark_20261104_013216_571_SIM_Bars.json",
+          "repetition": 0,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.1780999999999775e-05,
+              "p95": 0.00013
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.6072294089999994,
+              "p95": 3.342176599999996
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.609873524999997,
+              "p95": 3.4356933499999975
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/01-candidate/inspector_benchmark_20261104_013219_535_SIM_Bars.json",
+          "repetition": 0,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4496999999999552e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010304730000000002,
+              "p95": 0.010376999999999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.010570373999999999,
+              "p95": 0.010686
+            }
+          },
+          "raw_report": "warm-line-8-no-text/02-candidate/inspector_benchmark_20261104_013222_229_SIM_Bars.json",
+          "repetition": 1,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.3934999999999553e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010532982999999982,
+              "p95": 0.0105665
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.01080553200000001,
+              "p95": 0.010917499999999998
+            }
+          },
+          "raw_report": "warm-line-8-no-text/02-baseline/inspector_benchmark_20261104_013222_295_SIM_Bars.json",
+          "repetition": 1,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.7306e-05,
+              "p95": 0.00017
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.684861692000003,
+              "p95": 4.1979298
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.6860377070000028,
+              "p95": 4.19936335
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/02-candidate/inspector_benchmark_20261104_013222_611_SIM_Bars.json",
+          "repetition": 1,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 3.8730999999999836e-05,
+              "p95": 9e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.618201492999999,
+              "p95": 3.2167523499999997
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.619201807999994,
+              "p95": 3.21857035
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/02-baseline/inspector_benchmark_20261104_013225_638_SIM_Bars.json",
+          "repetition": 1,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.446699999999955e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010879385000000012,
+              "p95": 0.010507449999999998
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.01114946399999999,
+              "p95": 0.010807949999999998
+            }
+          },
+          "raw_report": "warm-line-8-no-text/03-baseline/inspector_benchmark_20261104_013228_325_SIM_Bars.json",
+          "repetition": 2,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4066999999999568e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.011743612000000004,
+              "p95": 0.0116175
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.012037020000000011,
+              "p95": 0.011934999999999992
+            }
+          },
+          "raw_report": "warm-line-8-no-text/03-candidate/inspector_benchmark_20261104_013228_401_SIM_Bars.json",
+          "repetition": 2,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.156500000000008e-05,
+              "p95": 0.00014
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.6412487390000035,
+              "p95": 3.264980249999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.6423755630000008,
+              "p95": 3.266884749999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/03-baseline/inspector_benchmark_20261104_013228_778_SIM_Bars.json",
+          "repetition": 2,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.83960000000001e-05,
+              "p95": 0.00010244999999999868
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.635777366000003,
+              "p95": 3.2285747999999996
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.637003816000001,
+              "p95": 3.2300142999999997
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/03-candidate/inspector_benchmark_20261104_013231_743_SIM_Bars.json",
+          "repetition": 2,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4996999999999547e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.013447868,
+              "p95": 0.014847999999999995
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.013876834000000022,
+              "p95": 0.015436499999999987
+            }
+          },
+          "raw_report": "warm-line-8-no-text/04-candidate/inspector_benchmark_20261104_013234_487_SIM_Bars.json",
+          "repetition": 3,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4688999999999567e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.011156789999999993,
+              "p95": 0.010896999999999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.01143419100000001,
+              "p95": 0.0111975
+            }
+          },
+          "raw_report": "warm-line-8-no-text/04-baseline/inspector_benchmark_20261104_013234_606_SIM_Bars.json",
+          "repetition": 3,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.4026999999999855e-05,
+              "p95": 0.00014
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.6268876889999992,
+              "p95": 3.0510333999999992
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.6279025689999997,
+              "p95": 3.053540799999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/04-candidate/inspector_benchmark_20261104_013234_937_SIM_Bars.json",
+          "repetition": 3,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.971300000000006e-05,
+              "p95": 0.00016
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.6858527690000003,
+              "p95": 4.28974615
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.6869245919999973,
+              "p95": 4.2923176
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/04-baseline/inspector_benchmark_20261104_013237_913_SIM_Bars.json",
+          "repetition": 3,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4024999999999564e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010395362,
+              "p95": 0.0105265
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.010667157999999993,
+              "p95": 0.010826
+            }
+          },
+          "raw_report": "warm-line-8-no-text/05-baseline/inspector_benchmark_20261104_013240_687_SIM_Bars.json",
+          "repetition": 4,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4167999999999576e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.011385050999999997,
+              "p95": 0.011169499999999997
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.011663307000000005,
+              "p95": 0.011608499999999997
+            }
+          },
+          "raw_report": "warm-line-8-no-text/05-candidate/inspector_benchmark_20261104_013240_762_SIM_Bars.json",
+          "repetition": 4,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.797599999999997e-05,
+              "p95": 0.00012144999999999959
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.6280493990000013,
+              "p95": 3.1980182999999993
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.6292564989999976,
+              "p95": 3.199518799999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/05-baseline/inspector_benchmark_20261104_013241_070_SIM_Bars.json",
+          "repetition": 4,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.9816000000000195e-05,
+              "p95": 0.00013049999999999954
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.6546198219999977,
+              "p95": 3.0565069499999997
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.6558522900000012,
+              "p95": 3.0583090499999996
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/05-candidate/inspector_benchmark_20261104_013244_016_SIM_Bars.json",
+          "repetition": 4,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.433799999999957e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.011302970999999992,
+              "p95": 0.011320999999999996
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.011583044000000002,
+              "p95": 0.011658449999999999
+            }
+          },
+          "raw_report": "warm-line-8-no-text/06-candidate/inspector_benchmark_20261104_013246_743_SIM_Bars.json",
+          "repetition": 5,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.428899999999955e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.011251548000000005,
+              "p95": 0.011231499999999997
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.011682293999999994,
+              "p95": 0.011682999999999994
+            }
+          },
+          "raw_report": "warm-line-8-no-text/06-baseline/inspector_benchmark_20261104_013246_813_SIM_Bars.json",
+          "repetition": 5,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.040700000000016e-05,
+              "p95": 0.000141
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.5750851259999963,
+              "p95": 2.9948870499999996
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.5761934889999987,
+              "p95": 2.9968464999999993
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/06-candidate/inspector_benchmark_20261104_013247_141_SIM_Bars.json",
+          "repetition": 5,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.454199999999998e-05,
+              "p95": 0.00013
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.5646613159999982,
+              "p95": 2.9498264999999995
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.565548297000004,
+              "p95": 2.9510280999999994
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/06-baseline/inspector_benchmark_20261104_013250_067_SIM_Bars.json",
+          "repetition": 5,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4219999999999565e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010793030000000007,
+              "p95": 0.010829499999999997
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.011086549,
+              "p95": 0.011161999999999997
+            }
+          },
+          "raw_report": "warm-line-8-no-text/07-baseline/inspector_benchmark_20261104_013252_709_SIM_Bars.json",
+          "repetition": 6,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.452999999999957e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.011519861000000008,
+              "p95": 0.011561549999999997
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.011830113999999997,
+              "p95": 0.0118985
+            }
+          },
+          "raw_report": "warm-line-8-no-text/07-candidate/inspector_benchmark_20261104_013252_780_SIM_Bars.json",
+          "repetition": 6,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.851300000000019e-05,
+              "p95": 0.00014144999999999962
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.746880014999996,
+              "p95": 4.05208735
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.748443681000007,
+              "p95": 4.052955799999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/07-baseline/inspector_benchmark_20261104_013253_175_SIM_Bars.json",
+          "repetition": 6,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.993300000000007e-05,
+              "p95": 8e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.8253305110000033,
+              "p95": 4.182198499999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.826736882,
+              "p95": 4.183395050000001
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/07-candidate/inspector_benchmark_20261104_013256_273_SIM_Bars.json",
+          "repetition": 6,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4318999999999575e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.011740942000000004,
+              "p95": 0.011041449999999996
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.012016013999999995,
+              "p95": 0.011400499999999996
+            }
+          },
+          "raw_report": "warm-line-8-no-text/08-candidate/inspector_benchmark_20261104_013259_197_SIM_Bars.json",
+          "repetition": 7,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.436399999999957e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.011550310999999992,
+              "p95": 0.012358949999999992
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.012065838999999995,
+              "p95": 0.012816999999999992
+            }
+          },
+          "raw_report": "warm-line-8-no-text/08-baseline/inspector_benchmark_20261104_013259_269_SIM_Bars.json",
+          "repetition": 7,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 7.683300000000014e-05,
+              "p95": 0.000171
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.916343996000001,
+              "p95": 4.500305749999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.917808272000004,
+              "p95": 4.502347349999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/08-candidate/inspector_benchmark_20261104_013259_643_SIM_Bars.json",
+          "repetition": 7,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.63440000000001e-05,
+              "p95": 0.00013
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.6887146560000024,
+              "p95": 4.28693515
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.689967916000002,
+              "p95": 4.288744699999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/08-baseline/inspector_benchmark_20261104_013302_955_SIM_Bars.json",
+          "repetition": 7,
+          "variant": "baseline"
+        }
+      ],
+      "status": "complete",
+      "summary": {
+        "cases": {
+          "warm-line-8-conservative-no-text": {
+            "counter_totals": {
+              "benchmark.frame.output_count": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 1000.0,
+                  "median": 1000.0,
+                  "min": 1000.0,
+                  "n": 8,
+                  "q25": 1000.0,
+                  "q75": 1000.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 1000.0,
+                  "median": 1000.0,
+                  "min": 1000.0,
+                  "n": 8,
+                  "q25": 1000.0,
+                  "q75": 1000.0
+                }
+              },
+              "benchmark.ring.occupancy": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 80000.0,
+                  "median": 80000.0,
+                  "min": 80000.0,
+                  "n": 8,
+                  "q25": 80000.0,
+                  "q75": 80000.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 80000.0,
+                  "median": 80000.0,
+                  "min": 80000.0,
+                  "n": 8,
+                  "q25": 80000.0,
+                  "q75": 80000.0
+                }
+              },
+              "benchmark.ring.overwritten_samples": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                }
+              },
+              "benchmark.ring.published_samples": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                }
+              }
+            },
+            "inclusive_scope_costs": {
+              "renderer.frame.finish": {
+                "baseline": {
+                  "available_runs": 8,
+                  "inclusive_ms_per_frame": {
+                    "iqr": 7.031299999999969e-05,
+                    "max": 0.0005286029999999991,
+                    "median": 0.0003938839999999998,
+                    "min": 0.00030808,
+                    "n": 8,
+                    "q25": 0.0003396257500000003,
+                    "q75": 0.00040993875
+                  }
+                },
+                "candidate": {
+                  "available_runs": 8,
+                  "inclusive_ms_per_frame": {
+                    "iqr": 5.106124999999968e-05,
+                    "max": 0.0005354419999999998,
+                    "median": 0.00035053950000000014,
+                    "min": 0.0003213750000000009,
+                    "n": 8,
+                    "q25": 0.00034322325000000017,
+                    "q75": 0.00039428449999999985
+                  }
+                }
+              }
+            },
+            "metrics": {
+              "benchmark.frame.cpu_allocation_bytes": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 9824,
+                    "median": 9824.0,
+                    "min": 9824,
+                    "n": 8,
+                    "q25": 9824.0,
+                    "q75": 9824.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 9824.0,
+                    "median": 9824.0,
+                    "min": 9824.0,
+                    "n": 8,
+                    "q25": 9824.0,
+                    "q75": 9824.0
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 9824,
+                    "median": 9824.0,
+                    "min": 9824,
+                    "n": 8,
+                    "q25": 9824.0,
+                    "q75": 9824.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 9824.0,
+                    "median": 9824.0,
+                    "min": 9824.0,
+                    "n": 8,
+                    "q25": 9824.0,
+                    "q75": 9824.0
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0,
+                    "median": 0.0,
+                    "min": 0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                }
+              },
+              "benchmark.frame.cpu_allocation_count": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 130,
+                    "median": 130.0,
+                    "min": 130,
+                    "n": 8,
+                    "q25": 130.0,
+                    "q75": 130.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 130.0,
+                    "median": 130.0,
+                    "min": 130.0,
+                    "n": 8,
+                    "q25": 130.0,
+                    "q75": 130.0
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 130,
+                    "median": 130.0,
+                    "min": 130,
+                    "n": 8,
+                    "q25": 130.0,
+                    "q75": 130.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 130.0,
+                    "median": 130.0,
+                    "min": 130.0,
+                    "n": 8,
+                    "q25": 130.0,
+                    "q75": 130.0
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0,
+                    "median": 0.0,
+                    "min": 0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                }
+              },
+              "benchmark.frame.gpu_finish_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 1.06155e-05,
+                    "max": 5.851300000000019e-05,
+                    "median": 5.063900000000007e-05,
+                    "min": 3.8730999999999836e-05,
+                    "n": 8,
+                    "q25": 4.5893500000000065e-05,
+                    "q75": 5.6509000000000065e-05
+                  },
+                  "run_p95s": {
+                    "iqr": 1.5724999999999827e-05,
+                    "max": 0.00016,
+                    "median": 0.00013499999999999997,
+                    "min": 9e-05,
+                    "n": 8,
+                    "q25": 0.0001278624999999999,
+                    "q75": 0.00014358749999999972
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 4.82800000000009e-06,
+                    "max": 7.683300000000014e-05,
+                    "median": 4.9874500000000134e-05,
+                    "min": 4.1780999999999775e-05,
+                    "n": 8,
+                    "q25": 4.7303750000000036e-05,
+                    "q75": 5.2131750000000126e-05
+                  },
+                  "run_p95s": {
+                    "iqr": 2.5137500000000333e-05,
+                    "max": 0.000171,
+                    "median": 0.00013524999999999976,
+                    "min": 8e-05,
+                    "n": 8,
+                    "q25": 0.00012311249999999967,
+                    "q75": 0.00014825
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 1.7307500000000037e-05,
+                    "max": 3.048900000000004e-05,
+                    "median": -4.427500000000093e-06,
+                    "min": -1.4239000000000322e-05,
+                    "n": 8,
+                    "q25": -8.264999999999859e-06,
+                    "q75": 9.042500000000178e-06
+                  },
+                  "percent_change": {
+                    "iqr": 36.08720477566129,
+                    "max": 65.78845157949245,
+                    "median": -8.791646773316792,
+                    "min": -25.417707961442872,
+                    "n": 8,
+                    "q25": -14.221944208954188,
+                    "q75": 21.865260566707107
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 4.288750000000037e-05,
+                    "max": 8e-05,
+                    "median": -5.475000000000025e-06,
+                    "min": -6.144999999999961e-05,
+                    "n": 8,
+                    "q25": -2.4387500000000345e-05,
+                    "q75": 1.8500000000000023e-05
+                  },
+                  "percent_change": {
+                    "iqr": 30.93612637362662,
+                    "max": 88.88888888888889,
+                    "median": -2.524186908192688,
+                    "min": -43.442912689996305,
+                    "n": 8,
+                    "q25": -16.705357142857373,
+                    "q75": 14.230769230769248
+                  }
+                }
+              },
+              "benchmark.frame.submission_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.07059248700000076,
+                    "max": 2.746880014999996,
+                    "median": 2.6346490690000026,
+                    "min": 2.5646613159999982,
+                    "n": 8,
+                    "q25": 2.61597575375,
+                    "q75": 2.6865682407500007
+                  },
+                  "run_p95s": {
+                    "iqr": 0.9527234250000003,
+                    "max": 4.28974615,
+                    "median": 3.2408662999999995,
+                    "min": 2.9498264999999995,
+                    "n": 8,
+                    "q25": 3.1580758749999998,
+                    "q75": 4.1107993
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.09800577775000363,
+                    "max": 2.916343996000001,
+                    "median": 2.645198594,
+                    "min": 2.5750851259999963,
+                    "n": 8,
+                    "q25": 2.6219731189999993,
+                    "q75": 2.719978896750003
+                  },
+                  "run_p95s": {
+                    "iqr": 1.1309927625,
+                    "max": 4.500305749999999,
+                    "median": 3.2853756999999977,
+                    "min": 2.9948870499999996,
+                    "n": 8,
+                    "q25": 3.0551385625,
+                    "q75": 4.186131325
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0725274617500068,
+                    "max": 0.22762933999999868,
+                    "median": 0.01849711649999719,
+                    "min": -0.058965080000001,
+                    "n": 8,
+                    "q25": -0.0029196885000021267,
+                    "q75": 0.06960777325000467
+                  },
+                  "percent_change": {
+                    "iqr": 2.73478039068987,
+                    "max": 8.466102547997512,
+                    "median": 0.7087360601410353,
+                    "min": -2.195395096878483,
+                    "n": 8,
+                    "q25": -0.11126140490342606,
+                    "q75": 2.623518985786444
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.29869187499999783,
+                    "max": 0.9811774500000001,
+                    "median": 0.08758584999999974,
+                    "min": -1.2387127500000008,
+                    "n": 8,
+                    "q25": -0.06268192499999936,
+                    "q75": 0.23600994999999847
+                  },
+                  "percent_change": {
+                    "iqr": 8.176284423781702,
+                    "max": 30.502113412616303,
+                    "median": 2.369266092192135,
+                    "min": -28.87613174966077,
+                    "n": 8,
+                    "q25": -1.9425136353518195,
+                    "q75": 6.233770788429882
+                  }
+                }
+              },
+              "benchmark.frame.total_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.07071334775000349,
+                    "max": 2.748443681000007,
+                    "median": 2.635816030999999,
+                    "min": 2.565548297000004,
+                    "n": 8,
+                    "q25": 2.616972075249995,
+                    "q75": 2.6876854229999987
+                  },
+                  "run_p95s": {
+                    "iqr": 0.9522642625,
+                    "max": 4.2923176,
+                    "median": 3.2427275499999997,
+                    "min": 2.9510280999999994,
+                    "n": 8,
+                    "q25": 3.1596387624999993,
+                    "q75": 4.111903024999999
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.09781719275000267,
+                    "max": 2.917808272000004,
+                    "median": 2.646428053000001,
+                    "min": 2.5761934889999987,
+                    "n": 8,
+                    "q25": 2.623395307999999,
+                    "q75": 2.721212500750002
+                  },
+                  "run_p95s": {
+                    "iqr": 1.130270137500001,
+                    "max": 4.502347349999999,
+                    "median": 3.3328538249999986,
+                    "min": 2.9968464999999993,
+                    "n": 8,
+                    "q25": 3.0571169874999997,
+                    "q75": 4.187387125000001
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.07135017525000631,
+                    "max": 0.22784035600000196,
+                    "median": 0.018620491499999225,
+                    "min": -0.05902202299999759,
+                    "n": 8,
+                    "q25": -0.0016499507500014055,
+                    "q75": 0.0697002245000049
+                  },
+                  "percent_change": {
+                    "iqr": 2.688568642528988,
+                    "max": 8.470002732924865,
+                    "median": 0.7132306514104569,
+                    "min": -2.1966386096479495,
+                    "n": 8,
+                    "q25": -0.06258479767293768,
+                    "q75": 2.62598384485605
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.322080937499999,
+                    "max": 0.9807929999999998,
+                    "median": 0.08812882500000052,
+                    "min": -1.2387768000000006,
+                    "n": 8,
+                    "q25": -0.06295527499999942,
+                    "q75": 0.2591256624999996
+                  },
+                  "percent_change": {
+                    "iqr": 8.939300798764481,
+                    "max": 30.47293963917861,
+                    "median": 2.3854991823261007,
+                    "min": -28.86032478118583,
+                    "n": 8,
+                    "q25": -1.949826014604211,
+                    "q75": 6.989474784160271
+                  }
+                }
+              }
+            }
+          },
+          "warm-line-8-no-text": {
+            "counter_totals": {
+              "benchmark.frame.output_count": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 1000.0,
+                  "median": 1000.0,
+                  "min": 1000.0,
+                  "n": 8,
+                  "q25": 1000.0,
+                  "q75": 1000.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 1000.0,
+                  "median": 1000.0,
+                  "min": 1000.0,
+                  "n": 8,
+                  "q25": 1000.0,
+                  "q75": 1000.0
+                }
+              },
+              "benchmark.ring.occupancy": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 80000.0,
+                  "median": 80000.0,
+                  "min": 80000.0,
+                  "n": 8,
+                  "q25": 80000.0,
+                  "q75": 80000.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 80000.0,
+                  "median": 80000.0,
+                  "min": 80000.0,
+                  "n": 8,
+                  "q25": 80000.0,
+                  "q75": 80000.0
+                }
+              },
+              "benchmark.ring.overwritten_samples": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                }
+              },
+              "benchmark.ring.published_samples": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                }
+              }
+            },
+            "inclusive_scope_costs": {
+              "renderer.frame.finish": {
+                "baseline": {
+                  "available_runs": 8,
+                  "inclusive_ms_per_frame": {
+                    "iqr": 3.5027499999993152e-06,
+                    "max": 0.00017261300000000074,
+                    "median": 0.000150301000000001,
+                    "min": 0.000146873000000001,
+                    "n": 8,
+                    "q25": 0.00014929575000000115,
+                    "q75": 0.00015279850000000046
+                  }
+                },
+                "candidate": {
+                  "available_runs": 8,
+                  "inclusive_ms_per_frame": {
+                    "iqr": 7.1997499999992495e-06,
+                    "max": 0.0002942509999999976,
+                    "median": 0.00015168750000000121,
+                    "min": 0.0001463120000000011,
+                    "n": 8,
+                    "q25": 0.0001490970000000011,
+                    "q75": 0.00015629675000000036
+                  }
+                }
+              }
+            },
+            "metrics": {
+              "benchmark.frame.cpu_allocation_bytes": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 9312,
+                    "median": 9312.0,
+                    "min": 9312,
+                    "n": 8,
+                    "q25": 9312.0,
+                    "q75": 9312.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 9312.0,
+                    "median": 9312.0,
+                    "min": 9312.0,
+                    "n": 8,
+                    "q25": 9312.0,
+                    "q75": 9312.0
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 9312,
+                    "median": 9312.0,
+                    "min": 9312,
+                    "n": 8,
+                    "q25": 9312.0,
+                    "q75": 9312.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 9312.0,
+                    "median": 9312.0,
+                    "min": 9312.0,
+                    "n": 8,
+                    "q25": 9312.0,
+                    "q75": 9312.0
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0,
+                    "median": 0.0,
+                    "min": 0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                }
+              },
+              "benchmark.frame.cpu_allocation_count": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 114,
+                    "median": 114.0,
+                    "min": 114,
+                    "n": 8,
+                    "q25": 114.0,
+                    "q75": 114.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 114.0,
+                    "median": 114.0,
+                    "min": 114.0,
+                    "n": 8,
+                    "q25": 114.0,
+                    "q75": 114.0
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 114,
+                    "median": 114.0,
+                    "min": 114,
+                    "n": 8,
+                    "q25": 114.0,
+                    "q75": 114.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 114.0,
+                    "median": 114.0,
+                    "min": 114.0,
+                    "n": 8,
+                    "q25": 114.0,
+                    "q75": 114.0
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0,
+                    "median": 0.0,
+                    "min": 0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                }
+              },
+              "benchmark.frame.gpu_finish_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 2.7099999999998775e-07,
+                    "max": 2.4688999999999567e-05,
+                    "median": 2.4326499999999558e-05,
+                    "min": 2.3934999999999553e-05,
+                    "n": 8,
+                    "q25": 2.4171249999999566e-05,
+                    "q75": 2.4442249999999554e-05
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 3e-05,
+                    "median": 3e-05,
+                    "min": 3e-05,
+                    "n": 8,
+                    "q25": 3e-05,
+                    "q75": 3e-05
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 3.384999999999799e-07,
+                    "max": 2.4996999999999547e-05,
+                    "median": 2.4328499999999572e-05,
+                    "min": 2.4066999999999568e-05,
+                    "n": 8,
+                    "q25": 2.4166749999999577e-05,
+                    "q75": 2.4505249999999557e-05
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 3e-05,
+                    "median": 3e-05,
+                    "min": 3e-05,
+                    "n": 8,
+                    "q25": 3e-05,
+                    "q75": 3e-05
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 4.0999999999997744e-07,
+                    "max": 5.61999999999999e-07,
+                    "median": 9.600000000001568e-08,
+                    "min": -3.999999999999826e-07,
+                    "n": 8,
+                    "q25": -1.0149999999999047e-07,
+                    "q75": 3.0849999999998697e-07
+                  },
+                  "percent_change": {
+                    "iqr": 1.6714244542114898,
+                    "max": 2.3480259034886597,
+                    "median": 0.3984753657281237,
+                    "min": -1.6348551109657494,
+                    "n": 8,
+                    "q25": -0.41580161592988385,
+                    "q75": 1.255622838281606
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                }
+              },
+              "benchmark.frame.submission_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0005207442499999913,
+                    "max": 0.011550310999999992,
+                    "median": 0.01083620750000001,
+                    "min": 0.010395362,
+                    "n": 8,
+                    "q25": 0.010659735250000005,
+                    "q75": 0.011180479499999996
+                  },
+                  "run_p95s": {
+                    "iqr": 0.00047021249999999737,
+                    "max": 0.012358949999999992,
+                    "median": 0.010863249999999998,
+                    "min": 0.010507449999999998,
+                    "n": 8,
+                    "q25": 0.0105565,
+                    "q75": 0.011026712499999997
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.00045925450000000936,
+                    "max": 0.013447868,
+                    "median": 0.011452456000000003,
+                    "min": 0.010304730000000002,
+                    "n": 8,
+                    "q25": 0.011282354999999994,
+                    "q75": 0.011741609500000003
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0004616749999999982,
+                    "max": 0.014847999999999995,
+                    "median": 0.011245249999999997,
+                    "min": 0.010376999999999999,
+                    "n": 8,
+                    "q25": 0.011113862499999998,
+                    "q75": 0.011575537499999997
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0007397634999999872,
+                    "max": 0.002291078000000007,
+                    "median": 0.0006226759999999965,
+                    "min": -0.00022825299999998036,
+                    "n": 8,
+                    "q25": 0.00015582900000000576,
+                    "q75": 0.000895592499999993
+                  },
+                  "percent_change": {
+                    "iqr": 6.9858175401418245,
+                    "max": 20.535279412806084,
+                    "median": 5.789677064670462,
+                    "min": -2.1670309351109807,
+                    "n": 8,
+                    "q25": 1.3520879175271616,
+                    "q75": 8.337905457668986
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0008068000000000007,
+                    "max": 0.003950999999999996,
+                    "median": 0.00041127499999999914,
+                    "min": -0.0013174999999999958,
+                    "n": 8,
+                    "q25": 1.974999999999937e-05,
+                    "q75": 0.0008265500000000001
+                  },
+                  "percent_change": {
+                    "iqr": 7.561636120117507,
+                    "max": 36.25768560154168,
+                    "median": 3.8734273734375213,
+                    "min": -10.660290720489984,
+                    "n": 8,
+                    "q25": 0.1492985476525459,
+                    "q75": 7.7109346677700525
+                  }
+                }
+              },
+              "benchmark.frame.total_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0005642070000000006,
+                    "max": 0.012065838999999995,
+                    "median": 0.011118006499999994,
+                    "min": 0.010667157999999993,
+                    "n": 8,
+                    "q25": 0.010932009750000006,
+                    "q75": 0.011496216750000007
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0005217499999999996,
+                    "max": 0.012816999999999992,
+                    "median": 0.011179749999999999,
+                    "min": 0.010807949999999998,
+                    "n": 8,
+                    "q25": 0.010894624999999998,
+                    "q75": 0.011416374999999998
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0004607802500000008,
+                    "max": 0.013876834000000022,
+                    "median": 0.0117467105,
+                    "min": 0.010570373999999999,
+                    "n": 8,
+                    "q25": 0.011560485249999999,
+                    "q75": 0.0120212655
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0004857125000000007,
+                    "max": 0.015436499999999987,
+                    "median": 0.011633474999999997,
+                    "min": 0.010686,
+                    "n": 8,
+                    "q25": 0.011421912499999997,
+                    "q75": 0.011907624999999998
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0009768855000000173,
+                    "max": 0.0024426430000000117,
+                    "median": 0.0006311024999999916,
+                    "min": -0.00023515800000001134,
+                    "n": 8,
+                    "q25": -6.218124999999783e-05,
+                    "q75": 0.0009147042500000195
+                  },
+                  "percent_change": {
+                    "iqr": 8.827112400345888,
+                    "max": 21.362621981738883,
+                    "median": 5.716459137629015,
+                    "min": -2.1762741529062213,
+                    "n": 8,
+                    "q25": -0.5221010892467681,
+                    "q75": 8.30501131109912
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0009449249999999919,
+                    "max": 0.004238999999999986,
+                    "median": 0.0004190250000000008,
+                    "min": -0.0014164999999999959,
+                    "n": 8,
+                    "q25": -7.62874999999958e-05,
+                    "q75": 0.0008686374999999961
+                  },
+                  "percent_change": {
+                    "iqr": 8.715683270092766,
+                    "max": 37.85666443402533,
+                    "median": 3.74738535951602,
+                    "min": -11.051728173519514,
+                    "n": 8,
+                    "q25": -0.6877129926441128,
+                    "q75": 8.027970277448654
+                  }
+                }
+              }
+            }
+          }
+        },
+        "frames_per_process": 1000,
+        "interpretation": {
+          "access_semantics": "Stable access identifies immutable benchmark callbacks so production caches can be exercised. The conservative control preserves uncached callback semantics; this workload correction is not a production optimization.",
+          "allocations": "C++ allocations observed on the render thread; excludes profiler storage, malloc-only and other-thread allocations.",
+          "cold": "Setup and cold observations remain in raw reports and are not mixed into warm-frame statistics.",
+          "frame_total": "Wall time for offscreen frame work, including QRhi completion with --finish; not application FPS or CPU time.",
+          "percent_change": "100 * (candidate / paired baseline - 1); negative means lower cost.",
+          "replicate": "One fresh process. No pooling of frames as independent replicates.",
+          "scope_costs": "Inclusive instrumented CPU-side scope wall times; nested scopes must not be added.",
+          "spread": "IQR and min/max describe process-to-process variation, not a confidence interval.",
+          "submission": "Includes begin/endOffscreenFrame and any backend synchronization they perform.",
+          "validation": "Timing runs exclude pixel readback. Validate pixels/semantics separately before accepting an optimization."
+        },
+        "repetitions": 8,
+        "schema_version": 1
+      },
+      "warmup_frames": 100
+    },
+    "retained-ab": {
+      "created_at": "2026-11-04T01:33:21.427909+00:00",
+      "ended_at": "2026-11-04T01:35:09.770506+00:00",
+      "executables": {
+        "baseline": {
+          "bytes": 2058480,
+          "git_at_binary_location": null,
+          "path": "/workspace/scratch/2a7852710aa2/benchmark-followup/bin/baseline",
+          "sha256": "a421c9d8832519110d6bc0eb2253916798eef0d30512f5359f46673c51f29f5d"
+        },
+        "candidate": {
+          "bytes": 2053392,
+          "git_at_binary_location": null,
+          "path": "/workspace/scratch/2a7852710aa2/benchmark-followup/bin/candidate",
+          "sha256": "77cfcf554e536ae0adfb4575ae8e7cf89623aa13fa99003e7df5088b96b21c9d"
+        }
+      },
+      "frames": 1000,
+      "host": {
+        "cpu_affinity": [
+          8
+        ],
+        "cpu_count": 9,
+        "cpu_model": "AMD EPYC 9V74 80-Core Processor",
+        "machine": "x86_64",
+        "platform": "Linux-6.18.57-x86_64-with-glibc2.39",
+        "python": "3.12.3",
+        "renderer_environment": {
+          "GALLIUM_DRIVER": null,
+          "LIBGL_ALWAYS_SOFTWARE": null,
+          "LP_NUM_THREADS": null,
+          "MESA_LOADER_DRIVER_OVERRIDE": null,
+          "QSG_RENDER_LOOP": null,
+          "QSG_RHI_BACKEND": null,
+          "QT_FONT_DPI": null,
+          "QT_QPA_PLATFORM": "offscreen",
+          "QT_SCALE_FACTOR": null,
+          "QT_SCREEN_SCALE_FACTORS": null,
+          "XDG_CACHE_HOME": null
+        }
+      },
+      "repetitions": 8,
+      "run_order": [
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 0,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 0,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 0,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 0,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 0,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 0,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 1,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 1,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 1,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 1,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 1,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 1,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 2,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 2,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 2,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 2,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 2,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 2,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 3,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 3,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 3,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 3,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 3,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 3,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 4,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 4,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 4,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 4,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 4,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 4,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 5,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 5,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 5,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 5,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 5,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 5,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 6,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 6,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 6,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 6,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 6,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 6,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 7,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "repetition": 7,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 7,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "repetition": 7,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 7,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "repetition": 7,
+          "variant": "baseline"
+        }
+      ],
+      "runs": [
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4204999999999576e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.01040927500000001,
+              "p95": 0.010506499999999998
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.010695401000000009,
+              "p95": 0.010816
+            }
+          },
+          "raw_report": "warm-line-8-no-text/01-baseline/inspector_benchmark_20261104_013321_487_SIM_Bars.json",
+          "repetition": 0,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4421999999999564e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010433991000000005,
+              "p95": 0.010607
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.010712358999999994,
+              "p95": 0.010946049999999999
+            }
+          },
+          "raw_report": "warm-line-8-no-text/01-candidate/inspector_benchmark_20261104_013321_553_SIM_Bars.json",
+          "repetition": 0,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 14464,
+              "p95": 14464.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 206,
+              "p95": 206.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 3.539299999999959e-05,
+              "p95": 7e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.6142385859999995,
+              "p95": 3.4980175999999994
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.615128909999998,
+              "p95": 3.4996925499999993
+            }
+          },
+          "raw_report": "warm-line-8-conservative/01-baseline/inspector_benchmark_20261104_013323_398_SIM_Bars.json",
+          "repetition": 0,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 13568,
+              "p95": 13568.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 168,
+              "p95": 168.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.151299999999965e-05,
+              "p95": 7.049999999999953e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.839410845999997,
+              "p95": 3.3406087499999995
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.8405753639999993,
+              "p95": 3.3422463
+            }
+          },
+          "raw_report": "warm-line-8-conservative/01-candidate/inspector_benchmark_20261104_013327_959_SIM_Bars.json",
+          "repetition": 0,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.894100000000009e-05,
+              "p95": 7.1e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.6160818230000005,
+              "p95": 3.0127752999999995
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.6172133050000035,
+              "p95": 3.0145007999999995
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/01-baseline/inspector_benchmark_20261104_013331_176_SIM_Bars.json",
+          "repetition": 0,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.702100000000011e-05,
+              "p95": 0.00013
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.727465207,
+              "p95": 3.0901769999999997
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.728446470000002,
+              "p95": 3.0914645000000003
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/01-candidate/inspector_benchmark_20261104_013334_110_SIM_Bars.json",
+          "repetition": 0,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.431499999999956e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010454657999999997,
+              "p95": 0.010606500000000001
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.010724690000000005,
+              "p95": 0.010917
+            }
+          },
+          "raw_report": "warm-line-8-no-text/02-candidate/inspector_benchmark_20261104_013336_931_SIM_Bars.json",
+          "repetition": 1,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4645999999999557e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.012212596999999997,
+              "p95": 0.013725499999999996
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.01252913699999999,
+              "p95": 0.014390999999999982
+            }
+          },
+          "raw_report": "warm-line-8-no-text/02-baseline/inspector_benchmark_20261104_013336_999_SIM_Bars.json",
+          "repetition": 1,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 13568,
+              "p95": 13568.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 168,
+              "p95": 168.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.610399999999985e-05,
+              "p95": 8e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.7562967440000046,
+              "p95": 3.58805305
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.757385669999999,
+              "p95": 3.5895795
+            }
+          },
+          "raw_report": "warm-line-8-conservative/02-candidate/inspector_benchmark_20261104_013337_359_SIM_Bars.json",
+          "repetition": 1,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 14464,
+              "p95": 14464.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 206,
+              "p95": 206.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.800500000000002e-05,
+              "p95": 7e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.702139047999997,
+              "p95": 3.553467699999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.7031875730000037,
+              "p95": 3.556285649999998
+            }
+          },
+          "raw_report": "warm-line-8-conservative/02-baseline/inspector_benchmark_20261104_013340_512_SIM_Bars.json",
+          "repetition": 1,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.615800000000017e-05,
+              "p95": 0.000131
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.789967340999997,
+              "p95": 4.193087349999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.791002088000002,
+              "p95": 4.19547375
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/02-candidate/inspector_benchmark_20261104_013343_537_SIM_Bars.json",
+          "repetition": 1,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.662600000000005e-05,
+              "p95": 0.00016005
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.595061771000002,
+              "p95": 3.182202349999997
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.5960724460000004,
+              "p95": 3.183542399999997
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/02-baseline/inspector_benchmark_20261104_013346_653_SIM_Bars.json",
+          "repetition": 1,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.434899999999957e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010709639000000012,
+              "p95": 0.010657
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.01097753400000002,
+              "p95": 0.010946499999999998
+            }
+          },
+          "raw_report": "warm-line-8-no-text/03-baseline/inspector_benchmark_20261104_013349_346_SIM_Bars.json",
+          "repetition": 2,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4664999999999558e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010447498999999999,
+              "p95": 0.010436
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.010717704999999996,
+              "p95": 0.01075745
+            }
+          },
+          "raw_report": "warm-line-8-no-text/03-candidate/inspector_benchmark_20261104_013349_425_SIM_Bars.json",
+          "repetition": 2,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 14464,
+              "p95": 14464.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 206,
+              "p95": 206.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.036600000000007e-05,
+              "p95": 0.00014
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 3.3716775639999983,
+              "p95": 4.5330778999999986
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 3.3732651549999946,
+              "p95": 4.534422399999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative/03-baseline/inspector_benchmark_20261104_013349_851_SIM_Bars.json",
+          "repetition": 2,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 13568,
+              "p95": 13568.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 168,
+              "p95": 168.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.263099999999994e-05,
+              "p95": 8e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.927684931000007,
+              "p95": 4.3638732
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.9290368799999964,
+              "p95": 4.3668431
+            }
+          },
+          "raw_report": "warm-line-8-conservative/03-candidate/inspector_benchmark_20261104_013353_608_SIM_Bars.json",
+          "repetition": 2,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 6.811500000000014e-05,
+              "p95": 0.00011099999999999909
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.914822576999998,
+              "p95": 4.483701249999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.916599870000001,
+              "p95": 4.48512785
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/03-baseline/inspector_benchmark_20261104_013356_872_SIM_Bars.json",
+          "repetition": 2,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.6067999999999905e-05,
+              "p95": 0.00014049999999999954
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.929441707,
+              "p95": 3.8753233499999995
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.9308143279999985,
+              "p95": 3.877595049999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/03-candidate/inspector_benchmark_20261104_013400_156_SIM_Bars.json",
+          "repetition": 2,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4846999999999557e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010868738999999999,
+              "p95": 0.010667999999999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.011174637999999997,
+              "p95": 0.0110685
+            }
+          },
+          "raw_report": "warm-line-8-no-text/04-candidate/inspector_benchmark_20261104_013403_161_SIM_Bars.json",
+          "repetition": 3,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.424999999999956e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.01123746499999999,
+              "p95": 0.010878999999999996
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.01151457299999999,
+              "p95": 0.011208449999999998
+            }
+          },
+          "raw_report": "warm-line-8-no-text/04-baseline/inspector_benchmark_20261104_013403_231_SIM_Bars.json",
+          "repetition": 3,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 13568,
+              "p95": 13568.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 168,
+              "p95": 168.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 7.134200000000025e-05,
+              "p95": 8e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.9437908609999983,
+              "p95": 4.548623200000001
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.945156260000004,
+              "p95": 4.5510816
+            }
+          },
+          "raw_report": "warm-line-8-conservative/04-candidate/inspector_benchmark_20261104_013403_675_SIM_Bars.json",
+          "repetition": 3,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 14464,
+              "p95": 14464.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 206,
+              "p95": 206.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.98559999999999e-05,
+              "p95": 9.09999999999991e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.746060523,
+              "p95": 3.8080336999999918
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.747220103999996,
+              "p95": 3.809748649999992
+            }
+          },
+          "raw_report": "warm-line-8-conservative/04-baseline/inspector_benchmark_20261104_013406_974_SIM_Bars.json",
+          "repetition": 3,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.427400000000009e-05,
+              "p95": 0.00014
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.8621292909999934,
+              "p95": 4.47782105
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.8633364649999984,
+              "p95": 4.479693599999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/04-candidate/inspector_benchmark_20261104_013410_117_SIM_Bars.json",
+          "repetition": 3,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.165199999999981e-05,
+              "p95": 6.1e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.7233444710000017,
+              "p95": 4.1721884
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.7244129709999965,
+              "p95": 4.173345899999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/04-baseline/inspector_benchmark_20261104_013413_329_SIM_Bars.json",
+          "repetition": 3,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.443299999999957e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.011192264999999996,
+              "p95": 0.010761999999999996
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.011465767999999994,
+              "p95": 0.011148499999999999
+            }
+          },
+          "raw_report": "warm-line-8-no-text/05-baseline/inspector_benchmark_20261104_013416_155_SIM_Bars.json",
+          "repetition": 4,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4476999999999583e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010959545999999994,
+              "p95": 0.0105765
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.01130187699999999,
+              "p95": 0.01090795
+            }
+          },
+          "raw_report": "warm-line-8-no-text/05-candidate/inspector_benchmark_20261104_013416_221_SIM_Bars.json",
+          "repetition": 4,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 14464,
+              "p95": 14464.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 206,
+              "p95": 206.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 7.145400000000128e-05,
+              "p95": 0.00012
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.5138479129999967,
+              "p95": 2.63902155
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.514766234,
+              "p95": 2.6400765
+            }
+          },
+          "raw_report": "warm-line-8-conservative/05-baseline/inspector_benchmark_20261104_013416_577_SIM_Bars.json",
+          "repetition": 4,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 13568,
+              "p95": 13568.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 168,
+              "p95": 168.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.392899999999977e-05,
+              "p95": 7e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.7054770649999993,
+              "p95": 3.1816387
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.7064125459999993,
+              "p95": 3.18282725
+            }
+          },
+          "raw_report": "warm-line-8-conservative/05-candidate/inspector_benchmark_20261104_013419_461_SIM_Bars.json",
+          "repetition": 4,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.916900000000024e-05,
+              "p95": 0.00014
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.7961885270000035,
+              "p95": 4.344526299999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.797932484999997,
+              "p95": 4.3479253
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/05-baseline/inspector_benchmark_20261104_013422_537_SIM_Bars.json",
+          "repetition": 4,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.26020000000002e-05,
+              "p95": 0.000131
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.827396767000003,
+              "p95": 3.3570132499999996
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.8285961610000028,
+              "p95": 3.3590167500000003
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/05-candidate/inspector_benchmark_20261104_013425_670_SIM_Bars.json",
+          "repetition": 4,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.456299999999955e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.012108120000000024,
+              "p95": 0.012336999999999992
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.012425664999999994,
+              "p95": 0.01283104999999998
+            }
+          },
+          "raw_report": "warm-line-8-no-text/06-candidate/inspector_benchmark_20261104_013428_590_SIM_Bars.json",
+          "repetition": 5,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 6.709200000000061e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.012307452000000003,
+              "p95": 0.014294999999999995
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.012724463000000002,
+              "p95": 0.015153999999999997
+            }
+          },
+          "raw_report": "warm-line-8-no-text/06-baseline/inspector_benchmark_20261104_013428_709_SIM_Bars.json",
+          "repetition": 5,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 13568,
+              "p95": 13568.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 168,
+              "p95": 168.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 6.43119999999999e-05,
+              "p95": 0.000161
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.9798528320000037,
+              "p95": 4.125246549999996
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.9814279499999965,
+              "p95": 4.126879149999997
+            }
+          },
+          "raw_report": "warm-line-8-conservative/06-candidate/inspector_benchmark_20261104_013429_128_SIM_Bars.json",
+          "repetition": 5,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 14464,
+              "p95": 14464.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 206,
+              "p95": 206.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.9029999999999976e-05,
+              "p95": 0.00013
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.874408772999997,
+              "p95": 4.373292449999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.8757487109999995,
+              "p95": 4.375113949999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative/06-baseline/inspector_benchmark_20261104_013432_552_SIM_Bars.json",
+          "repetition": 5,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 0.00015201599999999972,
+              "p95": 0.00014
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.9309554689999984,
+              "p95": 4.4732263
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.932508957,
+              "p95": 4.47546425
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/06-candidate/inspector_benchmark_20261104_013435_783_SIM_Bars.json",
+          "repetition": 5,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.1619999999999936e-05,
+              "p95": 0.00016
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.7703236000000016,
+              "p95": 3.8552077999999956
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.7718306890000006,
+              "p95": 3.857218749999996
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/06-baseline/inspector_benchmark_20261104_013439_061_SIM_Bars.json",
+          "repetition": 5,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.3975999999999562e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010431932999999984,
+              "p95": 0.010546499999999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.010697342000000004,
+              "p95": 0.010886
+            }
+          },
+          "raw_report": "warm-line-8-no-text/07-baseline/inspector_benchmark_20261104_013441_938_SIM_Bars.json",
+          "repetition": 6,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.416199999999958e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.010369180999999996,
+              "p95": 0.0105565
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.01065695499999999,
+              "p95": 0.01085745
+            }
+          },
+          "raw_report": "warm-line-8-no-text/07-candidate/inspector_benchmark_20261104_013442_012_SIM_Bars.json",
+          "repetition": 6,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 14464,
+              "p95": 14464.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 206,
+              "p95": 206.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.30190000000001e-05,
+              "p95": 8e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.706789235000003,
+              "p95": 3.240716849999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.7079494010000023,
+              "p95": 3.2419594
+            }
+          },
+          "raw_report": "warm-line-8-conservative/07-baseline/inspector_benchmark_20261104_013442_387_SIM_Bars.json",
+          "repetition": 6,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 13568,
+              "p95": 13568.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 168,
+              "p95": 168.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 4.639700000000008e-05,
+              "p95": 7e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.9027293629999993,
+              "p95": 4.4625485
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.9057075199999987,
+              "p95": 4.4636000000000005
+            }
+          },
+          "raw_report": "warm-line-8-conservative/07-candidate/inspector_benchmark_20261104_013445_465_SIM_Bars.json",
+          "repetition": 6,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.808400000000021e-05,
+              "p95": 0.00017
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.8278019880000014,
+              "p95": 4.3184613
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.829164223999995,
+              "p95": 4.3199518
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/07-baseline/inspector_benchmark_20261104_013448_761_SIM_Bars.json",
+          "repetition": 6,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 6.93429999999999e-05,
+              "p95": 0.00019
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 3.321001784000003,
+              "p95": 5.085474349999998
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 3.3228741330000005,
+              "p95": 5.088647949999999
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/07-candidate/inspector_benchmark_20261104_013451_929_SIM_Bars.json",
+          "repetition": 6,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4672999999999572e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.012161730999999983,
+              "p95": 0.014302499999999998
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.012447273999999984,
+              "p95": 0.014608499999999986
+            }
+          },
+          "raw_report": "warm-line-8-no-text/08-candidate/inspector_benchmark_20261104_013455_369_SIM_Bars.json",
+          "repetition": 7,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9312,
+              "p95": 9312.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 114,
+              "p95": 114.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 2.4544999999999566e-05,
+              "p95": 3e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 0.013081521000000002,
+              "p95": 0.01479509999999997
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 0.013399504000000001,
+              "p95": 0.015242549999999975
+            }
+          },
+          "raw_report": "warm-line-8-no-text/08-baseline/inspector_benchmark_20261104_013455_503_SIM_Bars.json",
+          "repetition": 7,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 13568,
+              "p95": 13568.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 168,
+              "p95": 168.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 5.764600000000018e-05,
+              "p95": 8e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 3.2745437179999994,
+              "p95": 4.64989385
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 3.2760978540000014,
+              "p95": 4.65190605
+            }
+          },
+          "raw_report": "warm-line-8-conservative/08-candidate/inspector_benchmark_20261104_013455_996_SIM_Bars.json",
+          "repetition": 7,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 14464,
+              "p95": 14464.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 206,
+              "p95": 206.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 9.381300000000026e-05,
+              "p95": 8e-05
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 2.818371475999998,
+              "p95": 4.174929399999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 2.820314807000001,
+              "p95": 4.1763774499999995
+            }
+          },
+          "raw_report": "warm-line-8-conservative/08-baseline/inspector_benchmark_20261104_013459_707_SIM_Bars.json",
+          "repetition": 7,
+          "variant": "baseline"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 0.00014679499999999953,
+              "p95": 0.00017
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 3.342323431999996,
+              "p95": 4.659945049999999
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 3.344440296999999,
+              "p95": 4.66177605
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/08-candidate/inspector_benchmark_20261104_013502_935_SIM_Bars.json",
+          "repetition": 7,
+          "variant": "candidate"
+        },
+        {
+          "case": "warm-line-8-conservative-no-text",
+          "counters": {
+            "benchmark.frame.output_count": 1000.0,
+            "benchmark.ring.occupancy": 80000.0,
+            "benchmark.ring.overwritten_samples": 0.0,
+            "benchmark.ring.published_samples": 0.0
+          },
+          "metrics": {
+            "benchmark.frame.cpu_allocation_bytes": {
+              "mean": 9824,
+              "p95": 9824.0
+            },
+            "benchmark.frame.cpu_allocation_count": {
+              "mean": 130,
+              "p95": 130.0
+            },
+            "benchmark.frame.gpu_finish_ms": {
+              "mean": 7.337900000000011e-05,
+              "p95": 0.000181
+            },
+            "benchmark.frame.submission_ms": {
+              "mean": 3.0896135130000046,
+              "p95": 4.58043385
+            },
+            "benchmark.frame.total_ms": {
+              "mean": 3.091600989999998,
+              "p95": 4.58298475
+            }
+          },
+          "raw_report": "warm-line-8-conservative-no-text/08-baseline/inspector_benchmark_20261104_013506_654_SIM_Bars.json",
+          "repetition": 7,
+          "variant": "baseline"
+        }
+      ],
+      "status": "complete",
+      "summary": {
+        "cases": {
+          "warm-line-8-conservative": {
+            "counter_totals": {
+              "benchmark.frame.output_count": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 1000.0,
+                  "median": 1000.0,
+                  "min": 1000.0,
+                  "n": 8,
+                  "q25": 1000.0,
+                  "q75": 1000.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 1000.0,
+                  "median": 1000.0,
+                  "min": 1000.0,
+                  "n": 8,
+                  "q25": 1000.0,
+                  "q75": 1000.0
+                }
+              },
+              "benchmark.ring.occupancy": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 80000.0,
+                  "median": 80000.0,
+                  "min": 80000.0,
+                  "n": 8,
+                  "q25": 80000.0,
+                  "q75": 80000.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 80000.0,
+                  "median": 80000.0,
+                  "min": 80000.0,
+                  "n": 8,
+                  "q25": 80000.0,
+                  "q75": 80000.0
+                }
+              },
+              "benchmark.ring.overwritten_samples": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                }
+              },
+              "benchmark.ring.published_samples": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                }
+              }
+            },
+            "inclusive_scope_costs": {
+              "renderer.frame.finish": {
+                "baseline": {
+                  "available_runs": 8,
+                  "inclusive_ms_per_frame": {
+                    "iqr": 6.800199999999962e-05,
+                    "max": 0.0005815600000000005,
+                    "median": 0.00039283000000000015,
+                    "min": 0.00032496200000000004,
+                    "n": 8,
+                    "q25": 0.0003689370000000005,
+                    "q75": 0.0004369390000000001
+                  }
+                },
+                "candidate": {
+                  "available_runs": 8,
+                  "inclusive_ms_per_frame": {
+                    "iqr": 0.00016998074999999903,
+                    "max": 0.0006235630000000004,
+                    "median": 0.0004325500000000005,
+                    "min": 0.0003632389999999996,
+                    "n": 8,
+                    "q25": 0.00038247850000000023,
+                    "q75": 0.0005524592499999993
+                  }
+                }
+              }
+            },
+            "metrics": {
+              "benchmark.frame.cpu_allocation_bytes": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 14464,
+                    "median": 14464.0,
+                    "min": 14464,
+                    "n": 8,
+                    "q25": 14464.0,
+                    "q75": 14464.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 14464.0,
+                    "median": 14464.0,
+                    "min": 14464.0,
+                    "n": 8,
+                    "q25": 14464.0,
+                    "q75": 14464.0
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 13568,
+                    "median": 13568.0,
+                    "min": 13568,
+                    "n": 8,
+                    "q25": 13568.0,
+                    "q75": 13568.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 13568.0,
+                    "median": 13568.0,
+                    "min": 13568.0,
+                    "n": 8,
+                    "q25": 13568.0,
+                    "q75": 13568.0
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": -896,
+                    "median": -896.0,
+                    "min": -896,
+                    "n": 8,
+                    "q25": -896.0,
+                    "q75": -896.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": -6.194690265486724,
+                    "median": -6.194690265486724,
+                    "min": -6.194690265486724,
+                    "n": 8,
+                    "q25": -6.194690265486724,
+                    "q75": -6.194690265486724
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": -896.0,
+                    "median": -896.0,
+                    "min": -896.0,
+                    "n": 8,
+                    "q25": -896.0,
+                    "q75": -896.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": -6.194690265486724,
+                    "median": -6.194690265486724,
+                    "min": -6.194690265486724,
+                    "n": 8,
+                    "q25": -6.194690265486724,
+                    "q75": -6.194690265486724
+                  }
+                }
+              },
+              "benchmark.frame.cpu_allocation_count": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 206,
+                    "median": 206.0,
+                    "min": 206,
+                    "n": 8,
+                    "q25": 206.0,
+                    "q75": 206.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 206.0,
+                    "median": 206.0,
+                    "min": 206.0,
+                    "n": 8,
+                    "q25": 206.0,
+                    "q75": 206.0
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 168,
+                    "median": 168.0,
+                    "min": 168,
+                    "n": 8,
+                    "q25": 168.0,
+                    "q75": 168.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 168.0,
+                    "median": 168.0,
+                    "min": 168.0,
+                    "n": 8,
+                    "q25": 168.0,
+                    "q75": 168.0
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": -38,
+                    "median": -38.0,
+                    "min": -38,
+                    "n": 8,
+                    "q25": -38.0,
+                    "q75": -38.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": -18.446601941747577,
+                    "median": -18.446601941747577,
+                    "min": -18.446601941747577,
+                    "n": 8,
+                    "q25": -18.446601941747577,
+                    "q75": -18.446601941747577
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": -38.0,
+                    "median": -38.0,
+                    "min": -38.0,
+                    "n": 8,
+                    "q25": -38.0,
+                    "q75": -38.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": -18.446601941747577,
+                    "median": -18.446601941747577,
+                    "min": -18.446601941747577,
+                    "n": 8,
+                    "q25": -18.446601941747577,
+                    "q75": -18.446601941747577
+                  }
+                }
+              },
+              "benchmark.frame.gpu_finish_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 8.854000000000407e-06,
+                    "max": 9.381300000000026e-05,
+                    "median": 5.011099999999998e-05,
+                    "min": 3.539299999999959e-05,
+                    "n": 8,
+                    "q25": 4.877374999999999e-05,
+                    "q75": 5.7627750000000394e-05
+                  },
+                  "run_p95s": {
+                    "iqr": 4.4999999999999996e-05,
+                    "max": 0.00014,
+                    "median": 8.549999999999956e-05,
+                    "min": 7e-05,
+                    "n": 8,
+                    "q25": 7.75e-05,
+                    "q75": 0.0001225
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 1.5708000000000298e-05,
+                    "max": 7.134200000000025e-05,
+                    "median": 4.6250499999999967e-05,
+                    "min": 4.151299999999965e-05,
+                    "n": 8,
+                    "q25": 4.360449999999981e-05,
+                    "q75": 5.931250000000011e-05
+                  },
+                  "run_p95s": {
+                    "iqr": 9.625000000000356e-06,
+                    "max": 0.000161,
+                    "median": 8e-05,
+                    "min": 7e-05,
+                    "n": 8,
+                    "q25": 7.037499999999965e-05,
+                    "q75": 8e-05
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 2.1093000000000504e-05,
+                    "max": 2.1486000000000356e-05,
+                    "median": -4.261500000000095e-06,
+                    "min": -3.616700000000008e-05,
+                    "n": 8,
+                    "q25": -1.268250000000048e-05,
+                    "q75": 8.410500000000022e-06
+                  },
+                  "percent_change": {
+                    "iqr": 41.90934265839596,
+                    "max": 43.09611681643213,
+                    "median": -8.224933145565833,
+                    "min": -38.552226237301845,
+                    "n": 8,
+                    "q25": -21.148508477605233,
+                    "q75": 20.760834180790727
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 2.3624999999998975e-05,
+                    "max": 3.100000000000002e-05,
+                    "median": -5.000000000000006e-06,
+                    "min": -5.999999999999998e-05,
+                    "n": 8,
+                    "q25": -2.074999999999932e-05,
+                    "q75": 2.8749999999996565e-06
+                  },
+                  "percent_change": {
+                    "iqr": 23.898809523809035,
+                    "max": 23.84615384615387,
+                    "median": -6.043956043955601,
+                    "min": -42.85714285714285,
+                    "n": 8,
+                    "q25": -19.791666666666675,
+                    "q75": 4.10714285714236
+                  }
+                }
+              },
+              "benchmark.frame.submission_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.15221686775000043,
+                    "max": 3.3716775639999983,
+                    "median": 2.7264248790000014,
+                    "min": 2.5138479129999967,
+                    "n": 8,
+                    "q25": 2.6801639324999975,
+                    "q75": 2.832380800249998
+                  },
+                  "run_p95s": {
+                    "iqr": 0.79082775,
+                    "max": 4.5330778999999986,
+                    "median": 3.6807506999999955,
+                    "min": 2.63902155,
+                    "n": 8,
+                    "q25": 3.4336924124999992,
+                    "q75": 4.224520162499999
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.13417403325000077,
+                    "max": 3.2745437179999994,
+                    "median": 2.915207147000003,
+                    "min": 2.7054770649999993,
+                    "n": 8,
+                    "q25": 2.818632320499999,
+                    "q75": 2.95280635375
+                  },
+                  "run_p95s": {
+                    "iqr": 0.9578752000000001,
+                    "max": 4.64989385,
+                    "median": 4.244559874999998,
+                    "min": 3.1816387,
+                    "n": 8,
+                    "q25": 3.5261919749999997,
+                    "q75": 4.484067175
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.1119683502499913,
+                    "max": 0.4561722420000014,
+                    "median": 0.1937846399999994,
+                    "min": -0.44399263299999125,
+                    "n": 8,
+                    "q25": 0.09262246825000675,
+                    "q75": 0.20459081849999805
+                  },
+                  "percent_change": {
+                    "iqr": 4.618187915984478,
+                    "max": 16.185667712172158,
+                    "median": 7.219674296726753,
+                    "min": -13.168300484618689,
+                    "n": 8,
+                    "q25": 3.252343553237086,
+                    "q75": 7.870531469221564
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.7524680500000022,
+                    "max": 1.2218316500000004,
+                    "median": 0.254774900000001,
+                    "min": -0.24804590000000282,
+                    "n": 8,
+                    "q25": -0.1603578124999997,
+                    "q75": 0.5921102375000025
+                  },
+                  "percent_change": {
+                    "iqr": 23.650872611263225,
+                    "max": 37.70251171434496,
+                    "median": 6.174935441311547,
+                    "min": -5.671834272139808,
+                    "n": 8,
+                    "q25": -3.924486323431159,
+                    "q75": 19.726386287832064
+                  }
+                }
+              },
+              "benchmark.frame.total_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.15300037574999825,
+                    "max": 3.3732651549999946,
+                    "median": 2.7275847524999994,
+                    "min": 2.514766234,
+                    "n": 8,
+                    "q25": 2.6811729072500023,
+                    "q75": 2.8341732830000006
+                  },
+                  "run_p95s": {
+                    "iqr": 0.7908023124999999,
+                    "max": 4.534422399999999,
+                    "median": 3.683017149999995,
+                    "min": 2.6400765,
+                    "n": 8,
+                    "q25": 3.4352592624999994,
+                    "q75": 4.226061574999999
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.1344462420000032,
+                    "max": 3.2760978540000014,
+                    "median": 2.9173721999999973,
+                    "min": 2.7064125459999993,
+                    "n": 8,
+                    "q25": 2.819777940499999,
+                    "q75": 2.954224182500002
+                  },
+                  "run_p95s": {
+                    "iqr": 0.9577242000000004,
+                    "max": 4.65190605,
+                    "median": 4.246861124999999,
+                    "min": 3.18282725,
+                    "n": 8,
+                    "q25": 3.5277462,
+                    "q75": 4.4854704000000005
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.11200477700000977,
+                    "max": 0.4557830470000006,
+                    "median": 0.19470221549999778,
+                    "min": -0.4442282749999982,
+                    "n": 8,
+                    "q25": 0.09280895349999652,
+                    "q75": 0.20481373050000629
+                  },
+                  "percent_change": {
+                    "iqr": 4.613469180390145,
+                    "max": 16.1607153169125,
+                    "median": 7.2539175907211595,
+                    "min": -13.169088541454988,
+                    "n": 8,
+                    "q25": 3.257374431146393,
+                    "q75": 7.870843611536538
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.7523758125000012,
+                    "max": 1.2216406000000006,
+                    "median": 0.25441122500000124,
+                    "min": -0.2482348000000023,
+                    "n": 8,
+                    "q25": -0.15997951249999942,
+                    "q75": 0.5923963000000018
+                  },
+                  "percent_change": {
+                    "iqr": 23.630167944457316,
+                    "max": 37.682168382491184,
+                    "median": 6.161173634438221,
+                    "min": -5.6737905077878565,
+                    "n": 8,
+                    "q25": -3.8965006432373746,
+                    "q75": 19.733667301219942
+                  }
+                }
+              }
+            }
+          },
+          "warm-line-8-conservative-no-text": {
+            "counter_totals": {
+              "benchmark.frame.output_count": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 1000.0,
+                  "median": 1000.0,
+                  "min": 1000.0,
+                  "n": 8,
+                  "q25": 1000.0,
+                  "q75": 1000.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 1000.0,
+                  "median": 1000.0,
+                  "min": 1000.0,
+                  "n": 8,
+                  "q25": 1000.0,
+                  "q75": 1000.0
+                }
+              },
+              "benchmark.ring.occupancy": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 80000.0,
+                  "median": 80000.0,
+                  "min": 80000.0,
+                  "n": 8,
+                  "q25": 80000.0,
+                  "q75": 80000.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 80000.0,
+                  "median": 80000.0,
+                  "min": 80000.0,
+                  "n": 8,
+                  "q25": 80000.0,
+                  "q75": 80000.0
+                }
+              },
+              "benchmark.ring.overwritten_samples": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                }
+              },
+              "benchmark.ring.published_samples": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                }
+              }
+            },
+            "inclusive_scope_costs": {
+              "renderer.frame.finish": {
+                "baseline": {
+                  "available_runs": 8,
+                  "inclusive_ms_per_frame": {
+                    "iqr": 0.00015681199999999977,
+                    "max": 0.0008389949999999999,
+                    "median": 0.0004783905000000001,
+                    "min": 0.0003717100000000003,
+                    "n": 8,
+                    "q25": 0.00040705349999999973,
+                    "q75": 0.0005638654999999995
+                  }
+                },
+                "candidate": {
+                  "available_runs": 8,
+                  "inclusive_ms_per_frame": {
+                    "iqr": 0.00016696774999999968,
+                    "max": 0.0009290840000000005,
+                    "median": 0.0004461609999999995,
+                    "min": 0.0003369419999999998,
+                    "n": 8,
+                    "q25": 0.00038698350000000064,
+                    "q75": 0.0005539512500000003
+                  }
+                }
+              }
+            },
+            "metrics": {
+              "benchmark.frame.cpu_allocation_bytes": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 9824,
+                    "median": 9824.0,
+                    "min": 9824,
+                    "n": 8,
+                    "q25": 9824.0,
+                    "q75": 9824.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 9824.0,
+                    "median": 9824.0,
+                    "min": 9824.0,
+                    "n": 8,
+                    "q25": 9824.0,
+                    "q75": 9824.0
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 9824,
+                    "median": 9824.0,
+                    "min": 9824,
+                    "n": 8,
+                    "q25": 9824.0,
+                    "q75": 9824.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 9824.0,
+                    "median": 9824.0,
+                    "min": 9824.0,
+                    "n": 8,
+                    "q25": 9824.0,
+                    "q75": 9824.0
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0,
+                    "median": 0.0,
+                    "min": 0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                }
+              },
+              "benchmark.frame.cpu_allocation_count": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 130,
+                    "median": 130.0,
+                    "min": 130,
+                    "n": 8,
+                    "q25": 130.0,
+                    "q75": 130.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 130.0,
+                    "median": 130.0,
+                    "min": 130.0,
+                    "n": 8,
+                    "q25": 130.0,
+                    "q75": 130.0
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 130,
+                    "median": 130.0,
+                    "min": 130,
+                    "n": 8,
+                    "q25": 130.0,
+                    "q75": 130.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 130.0,
+                    "median": 130.0,
+                    "min": 130.0,
+                    "n": 8,
+                    "q25": 130.0,
+                    "q75": 130.0
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0,
+                    "median": 0.0,
+                    "min": 0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                }
+              },
+              "benchmark.frame.gpu_finish_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 1.1479749999999988e-05,
+                    "max": 7.337900000000011e-05,
+                    "median": 5.4123e-05,
+                    "min": 4.165199999999981e-05,
+                    "n": 8,
+                    "q25": 4.91120000000002e-05,
+                    "q75": 6.059175000000019e-05
+                  },
+                  "run_p95s": {
+                    "iqr": 6.153750000000066e-05,
+                    "max": 0.000181,
+                    "median": 0.00015000000000000001,
+                    "min": 6.1e-05,
+                    "n": 8,
+                    "q25": 0.00010099999999999932,
+                    "q75": 0.0001625375
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 3.771499999999962e-05,
+                    "max": 0.00015201599999999972,
+                    "median": 5.56475000000001e-05,
+                    "min": 4.6067999999999905e-05,
+                    "n": 8,
+                    "q25": 5.099100000000019e-05,
+                    "q75": 8.870599999999981e-05
+                  },
+                  "run_p95s": {
+                    "iqr": 1.6874999999999638e-05,
+                    "max": 0.00019,
+                    "median": 0.00014,
+                    "min": 0.00013,
+                    "n": 8,
+                    "q25": 0.000131,
+                    "q75": 0.00014787499999999965
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 2.7862750000000065e-05,
+                    "max": 0.00010039599999999978,
+                    "median": 9.66949999999985e-06,
+                    "min": -2.2047000000000238e-05,
+                    "n": 8,
+                    "q25": -4.225000000000116e-08,
+                    "q75": 2.7820500000000063e-05
+                  },
+                  "percent_change": {
+                    "iqr": 47.12522669123591,
+                    "max": 194.49050755521097,
+                    "median": 17.946835253641325,
+                    "min": -32.36731997357438,
+                    "n": 8,
+                    "q25": 0.6149792104016818,
+                    "q75": 47.74020590163759
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 5.012500000000033e-05,
+                    "max": 7.9e-05,
+                    "median": 5.500000000000012e-06,
+                    "min": -2.9049999999999974e-05,
+                    "n": 8,
+                    "q25": -1.3250000000000004e-05,
+                    "q75": 3.687500000000033e-05
+                  },
+                  "percent_change": {
+                    "iqr": 48.65350889118538,
+                    "max": 129.50819672131146,
+                    "median": 2.843678908027303,
+                    "min": -18.150577944392367,
+                    "n": 8,
+                    "q25": -7.946428571428557,
+                    "q75": 40.70708031975683
+                  }
+                }
+              },
+              "benchmark.frame.submission_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.15302832624999896,
+                    "max": 3.0896135130000046,
+                    "median": 2.7832560635000023,
+                    "min": 2.595061771000002,
+                    "n": 8,
+                    "q25": 2.6965288090000015,
+                    "q75": 2.8495571352500004
+                  },
+                  "run_p95s": {
+                    "iqr": 0.6923636000000033,
+                    "max": 4.58043385,
+                    "median": 4.245324849999999,
+                    "min": 3.0127752999999995,
+                    "n": 8,
+                    "q25": 3.686956437499996,
+                    "q75": 4.379320037499999
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.21042763724999825,
+                    "max": 3.342323431999996,
+                    "median": 2.895785498999997,
+                    "min": 2.727465207,
+                    "n": 8,
+                    "q25": 2.8180394105000013,
+                    "q75": 3.0284670477499995
+                  },
+                  "run_p95s": {
+                    "iqr": 0.7776062250000004,
+                    "max": 5.085474349999998,
+                    "median": 4.333156825,
+                    "min": 3.0901769999999997,
+                    "n": 8,
+                    "q25": 3.7457458249999993,
+                    "q75": 4.52335205
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.11801705924999484,
+                    "max": 0.49319979600000163,
+                    "median": 0.14970834449999426,
+                    "min": 0.014619130000002034,
+                    "n": 8,
+                    "q25": 0.09133959799999936,
+                    "q75": 0.2093566572499942
+                  },
+                  "percent_change": {
+                    "iqr": 4.205553361281495,
+                    "max": 17.44110083000625,
+                    "median": 5.4472120219066,
+                    "min": 0.5015444204171216,
+                    "n": 8,
+                    "q25": 3.4722559055689715,
+                    "q75": 7.677809266850466
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.7493103375000029,
+                    "max": 1.0108850000000018,
+                    "median": 0.19257192499999976,
+                    "min": -0.9875130499999996,
+                    "n": 8,
+                    "q25": -0.09404319999999977,
+                    "q75": 0.6552671375000031
+                  },
+                  "percent_change": {
+                    "iqr": 18.55362009159056,
+                    "max": 31.76683594618057,
+                    "median": 4.947296009337787,
+                    "min": -22.73005114504658,
+                    "n": 8,
+                    "q25": -2.090247475164963,
+                    "q75": 16.4633726164256
+                  }
+                }
+              },
+              "benchmark.frame.total_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.1534100809999983,
+                    "max": 3.091600989999998,
+                    "median": 2.7848815869999988,
+                    "min": 2.5960724460000004,
+                    "n": 8,
+                    "q25": 2.6976130544999983,
+                    "q75": 2.8510231354999966
+                  },
+                  "run_p95s": {
+                    "iqr": 0.6934262750000033,
+                    "max": 4.58298475,
+                    "median": 4.24664885,
+                    "min": 3.0145007999999995,
+                    "n": 8,
+                    "q25": 3.688799662499996,
+                    "q75": 4.3822259374999994
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.21090260824999785,
+                    "max": 3.344440296999999,
+                    "median": 2.8970753964999982,
+                    "min": 2.728446470000002,
+                    "n": 8,
+                    "q25": 2.8191976427500025,
+                    "q75": 3.0301002510000004
+                  },
+                  "run_p95s": {
+                    "iqr": 0.7772637375000002,
+                    "max": 5.088647949999999,
+                    "median": 4.335469,
+                    "min": 3.0914645000000003,
+                    "n": 8,
+                    "q25": 3.7479504749999997,
+                    "q75": 4.5252142125
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.11831626550000118,
+                    "max": 0.49370990900000544,
+                    "median": 0.14980088100000066,
+                    "min": 0.014214457999997432,
+                    "n": 8,
+                    "q25": 0.09109079275000032,
+                    "q75": 0.2094070582500015
+                  },
+                  "percent_change": {
+                    "iqr": 4.214512501469791,
+                    "max": 17.450733499732184,
+                    "median": 5.448018369940899,
+                    "min": 0.4873640071854535,
+                    "n": 8,
+                    "q25": 3.4615309686010565,
+                    "q75": 7.676043470070848
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.7500185875000022,
+                    "max": 1.0119313500000024,
+                    "median": 0.19256950000000028,
+                    "min": -0.9889085499999997,
+                    "n": 8,
+                    "q25": -0.09416042499999955,
+                    "q75": 0.6558581625000026
+                  },
+                  "percent_change": {
+                    "iqr": 18.56669015105164,
+                    "max": 31.786331791905887,
+                    "median": 4.946846830984142,
+                    "min": -22.744377646046487,
+                    "n": 8,
+                    "q25": -2.096963677330125,
+                    "q75": 16.46972647372151
+                  }
+                }
+              }
+            }
+          },
+          "warm-line-8-no-text": {
+            "counter_totals": {
+              "benchmark.frame.output_count": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 1000.0,
+                  "median": 1000.0,
+                  "min": 1000.0,
+                  "n": 8,
+                  "q25": 1000.0,
+                  "q75": 1000.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 1000.0,
+                  "median": 1000.0,
+                  "min": 1000.0,
+                  "n": 8,
+                  "q25": 1000.0,
+                  "q75": 1000.0
+                }
+              },
+              "benchmark.ring.occupancy": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 80000.0,
+                  "median": 80000.0,
+                  "min": 80000.0,
+                  "n": 8,
+                  "q25": 80000.0,
+                  "q75": 80000.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 80000.0,
+                  "median": 80000.0,
+                  "min": 80000.0,
+                  "n": 8,
+                  "q25": 80000.0,
+                  "q75": 80000.0
+                }
+              },
+              "benchmark.ring.overwritten_samples": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                }
+              },
+              "benchmark.ring.published_samples": {
+                "baseline": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                },
+                "candidate": {
+                  "iqr": 0.0,
+                  "max": 0.0,
+                  "median": 0.0,
+                  "min": 0.0,
+                  "n": 8,
+                  "q25": 0.0,
+                  "q75": 0.0
+                }
+              }
+            },
+            "inclusive_scope_costs": {
+              "renderer.frame.finish": {
+                "baseline": {
+                  "available_runs": 8,
+                  "inclusive_ms_per_frame": {
+                    "iqr": 6.185750000000035e-06,
+                    "max": 0.000260618,
+                    "median": 0.00015010500000000096,
+                    "min": 0.00014608300000000082,
+                    "n": 8,
+                    "q25": 0.00014701825000000118,
+                    "q75": 0.0001532040000000012
+                  }
+                },
+                "candidate": {
+                  "available_runs": 8,
+                  "inclusive_ms_per_frame": {
+                    "iqr": 1.9857999999999226e-05,
+                    "max": 0.0002146880000000022,
+                    "median": 0.0001549675000000007,
+                    "min": 0.00014365000000000113,
+                    "n": 8,
+                    "q25": 0.00014909550000000114,
+                    "q75": 0.00016895350000000037
+                  }
+                }
+              }
+            },
+            "metrics": {
+              "benchmark.frame.cpu_allocation_bytes": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 9312,
+                    "median": 9312.0,
+                    "min": 9312,
+                    "n": 8,
+                    "q25": 9312.0,
+                    "q75": 9312.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 9312.0,
+                    "median": 9312.0,
+                    "min": 9312.0,
+                    "n": 8,
+                    "q25": 9312.0,
+                    "q75": 9312.0
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 9312,
+                    "median": 9312.0,
+                    "min": 9312,
+                    "n": 8,
+                    "q25": 9312.0,
+                    "q75": 9312.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 9312.0,
+                    "median": 9312.0,
+                    "min": 9312.0,
+                    "n": 8,
+                    "q25": 9312.0,
+                    "q75": 9312.0
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0,
+                    "median": 0.0,
+                    "min": 0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                }
+              },
+              "benchmark.frame.cpu_allocation_count": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 114,
+                    "median": 114.0,
+                    "min": 114,
+                    "n": 8,
+                    "q25": 114.0,
+                    "q75": 114.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 114.0,
+                    "median": 114.0,
+                    "min": 114.0,
+                    "n": 8,
+                    "q25": 114.0,
+                    "q75": 114.0
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0,
+                    "max": 114,
+                    "median": 114.0,
+                    "min": 114,
+                    "n": 8,
+                    "q25": 114.0,
+                    "q75": 114.0
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 114.0,
+                    "median": 114.0,
+                    "min": 114.0,
+                    "n": 8,
+                    "q25": 114.0,
+                    "q75": 114.0
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0,
+                    "median": 0.0,
+                    "min": 0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                }
+              },
+              "benchmark.frame.gpu_finish_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 3.3149999999999844e-07,
+                    "max": 6.709200000000061e-05,
+                    "median": 2.439099999999957e-05,
+                    "min": 2.3975999999999562e-05,
+                    "n": 8,
+                    "q25": 2.4238749999999565e-05,
+                    "q75": 2.4570249999999564e-05
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 3e-05,
+                    "median": 3e-05,
+                    "min": 3e-05,
+                    "n": 8,
+                    "q25": 3e-05,
+                    "q75": 3e-05
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 2.7174999999999956e-07,
+                    "max": 2.4846999999999557e-05,
+                    "median": 2.451999999999957e-05,
+                    "min": 2.416199999999958e-05,
+                    "n": 8,
+                    "q25": 2.4395249999999563e-05,
+                    "q75": 2.4666999999999562e-05
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0,
+                    "max": 3e-05,
+                    "median": 3e-05,
+                    "min": 3e-05,
+                    "n": 8,
+                    "q25": 3e-05,
+                    "q75": 3e-05
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 2.914999999999785e-07,
+                    "max": 5.969999999999978e-07,
+                    "median": 1.5700000000001222e-07,
+                    "min": -4.2529000000001056e-05,
+                    "n": 8,
+                    "q25": -4.97499999999905e-08,
+                    "q75": 2.41749999999988e-07
+                  },
+                  "percent_change": {
+                    "iqr": 1.1975214284276807,
+                    "max": 2.4618556701031302,
+                    "median": 0.648633457250336,
+                    "min": -63.3890776843747,
+                    "n": 8,
+                    "q25": -0.20069104646292235,
+                    "q75": 0.9968303819647584
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  },
+                  "percent_change": {
+                    "iqr": 0.0,
+                    "max": 0.0,
+                    "median": 0.0,
+                    "min": 0.0,
+                    "n": 8,
+                    "q25": 0.0,
+                    "q75": 0.0
+                  }
+                }
+              },
+              "benchmark.frame.submission_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.0015960982499999936,
+                    "max": 0.013081521000000002,
+                    "median": 0.011214864999999994,
+                    "min": 0.01040927500000001,
+                    "n": 8,
+                    "q25": 0.010640212500000005,
+                    "q75": 0.012236310749999998
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0032384999999999966,
+                    "max": 0.01479509999999997,
+                    "median": 0.010820499999999997,
+                    "min": 0.010506499999999998,
+                    "n": 8,
+                    "q25": 0.010629375,
+                    "q75": 0.013867874999999997
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0008025675000000003,
+                    "max": 0.012161730999999983,
+                    "median": 0.010661698499999997,
+                    "min": 0.010369180999999996,
+                    "n": 8,
+                    "q25": 0.010444122,
+                    "q75": 0.0112466895
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0005137499999999968,
+                    "max": 0.014302499999999998,
+                    "median": 0.010606750000000002,
+                    "min": 0.010436,
+                    "n": 8,
+                    "q25": 0.010571500000000001,
+                    "q75": 0.011085249999999998
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.000341305000000017,
+                    "max": 2.471599999999581e-05,
+                    "median": -0.00024742950000000794,
+                    "min": -0.001757939,
+                    "n": 8,
+                    "q25": -0.0005064919999999981,
+                    "q75": -0.00016518699999998115
+                  },
+                  "percent_change": {
+                    "iqr": 2.8536318509762486,
+                    "max": 0.23744208890623675,
+                    "median": -2.2634928858976444,
+                    "min": -14.394473182075851,
+                    "n": 8,
+                    "q25": -4.21871934448752,
+                    "q75": -1.3650874935112718
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.000722324999999985,
+                    "max": 0.00010050000000000163,
+                    "median": -0.0002159999999999983,
+                    "min": -0.003118999999999995,
+                    "n": 8,
+                    "q25": -0.0008589499999999807,
+                    "q75": -0.0001366249999999957
+                  },
+                  "percent_change": {
+                    "iqr": 4.652346313550029,
+                    "max": 0.9565507067053947,
+                    "median": -2.006635419774377,
+                    "min": -22.724126625623807,
+                    "n": 8,
+                    "q25": -5.92138475159332,
+                    "q75": -1.2690384380432906
+                  }
+                }
+              },
+              "benchmark.frame.total_ms": {
+                "baseline": {
+                  "run_means": {
+                    "iqr": 0.001670482499999978,
+                    "max": 0.013399504000000001,
+                    "median": 0.011490170499999992,
+                    "min": 0.010695401000000009,
+                    "n": 8,
+                    "q25": 0.010907486000000015,
+                    "q75": 0.012577968499999993
+                  },
+                  "run_p95s": {
+                    "iqr": 0.003650374999999987,
+                    "max": 0.015242549999999975,
+                    "median": 0.011178474999999998,
+                    "min": 0.010816,
+                    "n": 8,
+                    "q25": 0.010931374999999998,
+                    "q75": 0.014581749999999985
+                  }
+                },
+                "candidate": {
+                  "run_means": {
+                    "iqr": 0.0008664554999999966,
+                    "max": 0.012447273999999984,
+                    "median": 0.010949664000000001,
+                    "min": 0.01065695499999999,
+                    "n": 8,
+                    "q25": 0.010716368499999995,
+                    "q75": 0.011582823999999992
+                  },
+                  "run_p95s": {
+                    "iqr": 0.0006138124999999963,
+                    "max": 0.014608499999999986,
+                    "median": 0.010931525,
+                    "min": 0.01075745,
+                    "n": 8,
+                    "q25": 0.010895324999999999,
+                    "q75": 0.011509137499999995
+                  }
+                },
+                "paired_means": {
+                  "absolute_change": {
+                    "iqr": 0.0003599937499999921,
+                    "max": 1.6957999999985332e-05,
+                    "median": -0.000279313500000016,
+                    "min": -0.001804446999999985,
+                    "n": 8,
+                    "q25": -0.0004930087499999988,
+                    "q75": -0.00013301500000000672
+                  },
+                  "percent_change": {
+                    "iqr": 2.8243447389851934,
+                    "max": 0.15855412994787432,
+                    "median": -2.357566447530685,
+                    "min": -14.402005501256687,
+                    "n": 8,
+                    "q25": -3.990775835966404,
+                    "q75": -1.1664310969812104
+                  }
+                },
+                "paired_p95s": {
+                  "absolute_change": {
+                    "iqr": 0.0009441749999999972,
+                    "max": 0.0001300499999999996,
+                    "median": -0.0002147999999999985,
+                    "min": -0.0034739999999999823,
+                    "n": 8,
+                    "q25": -0.0010562749999999958,
+                    "q75": -0.00011209999999999866
+                  },
+                  "percent_change": {
+                    "iqr": 5.950017283330344,
+                    "max": 1.2023853550295893,
+                    "median": -1.9423627070843996,
+                    "min": -24.14008755472161,
+                    "n": 8,
+                    "q25": -6.952041801705308,
+                    "q75": -1.0020245183749639
+                  }
+                }
+              }
+            }
+          }
+        },
+        "frames_per_process": 1000,
+        "interpretation": {
+          "access_semantics": "Stable access identifies immutable benchmark callbacks so production caches can be exercised. The conservative control preserves uncached callback semantics; this workload correction is not a production optimization.",
+          "allocations": "C++ allocations observed on the render thread; excludes profiler storage, malloc-only and other-thread allocations.",
+          "cold": "Setup and cold observations remain in raw reports and are not mixed into warm-frame statistics.",
+          "frame_total": "Wall time for offscreen frame work, including QRhi completion with --finish; not application FPS or CPU time.",
+          "percent_change": "100 * (candidate / paired baseline - 1); negative means lower cost.",
+          "replicate": "One fresh process. No pooling of frames as independent replicates.",
+          "scope_costs": "Inclusive instrumented CPU-side scope wall times; nested scopes must not be added.",
+          "spread": "IQR and min/max describe process-to-process variation, not a confidence interval.",
+          "submission": "Includes begin/endOffscreenFrame and any backend synchronization they perform.",
+          "validation": "Timing runs exclude pixel readback. Validate pixels/semantics separately before accepting an optimization."
+        },
+        "repetitions": 8,
+        "schema_version": 1
+      },
+      "warmup_frames": 100
+    }
+  },
+  "initial_plan": {
+    "backend": "null",
+    "binary_sha256": {
+      "baseline": "a421c9d8832519110d6bc0eb2253916798eef0d30512f5359f46673c51f29f5d",
+      "candidate": "77cfcf554e536ae0adfb4575ae8e7cf89623aa13fa99003e7df5088b96b21c9d"
+    },
+    "campaigns": [
+      {
+        "baseline": "baseline",
+        "candidate": "baseline",
+        "cases": [
+          "warm-line-8-no-text",
+          "warm-line-8-conservative-no-text"
+        ],
+        "name": "retained-aa",
+        "repetitions": 8
+      },
+      {
+        "baseline": "baseline",
+        "candidate": "candidate",
+        "cases": [
+          "warm-line-8-no-text",
+          "warm-line-8-conservative",
+          "warm-line-8-conservative-no-text"
+        ],
+        "name": "retained-ab",
+        "repetitions": 8
+      }
+    ],
+    "cpu_affinity": [
+      8
+    ],
+    "created_at": "2026-11-04T01:32:15.682916+00:00",
+    "decision_rules": [
+      "Retain all observations and failed invocations; no favorable-result retries.",
+      "If identical-binary variation is comparable to the effect, timing remains unresolved.",
+      "If no-text slowdown reproduces, inspect source-independent binary/layout effects and do one causally motivated follow-up.",
+      "Allocation and timing findings remain separate; native pixel/render tests required before promotion.",
+      "Do not repeat the full original campaign or rebuild unchanged dependencies without a concrete reason."
+    ],
+    "frame_timing_only": true,
+    "frames": 1000,
+    "original_affinity": [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8
+    ],
+    "purpose": "Continue PR30; assess reproducibility of conservative/no-text slowdown before promoting label optimization",
+    "warmup_frames": 100
+  },
+  "schema_version": 1,
+  "status": "checkpoint"
+}

From 56a2055638b4dc64c90884f9f5fb1884675af92b Mon Sep 17 00:00:00 2001
From: Ioannis Makris <imak@imak.gr>
Date: Wed, 4 Nov 2026 02:39:43 +0100
Subject: [PATCH 4/5] Keep frame-only measurements outside profiler bookkeeping
 [skip ci]

Guard the remaining preparation lookup and finish scope, then store harness observations after closing frame timing and allocation accounting. Reject internal renderer scopes and observations in frame-only reports.

Advance the workload contract to v3 so historical v2 timings are not silently compared with the corrected boundary. The existing Python validator now passes ten focused tests and rejects the retained report's unexpected renderer.frame.finish scope. Native C++ verification is continuing on this draft.
---
 benchmark/README.md                   | 12 +++++-
 benchmark/src/benchmark_window.cpp    | 54 ++++++++++++++++-----------
 benchmark/src/main.cpp                |  2 +-
 benchmark/tools/run_suite.py          | 15 +++++++-
 benchmark/tools/test_run_suite.py     | 16 +++++++-
 benchmark/tools/validate_workloads.py |  4 +-
 6 files changed, 76 insertions(+), 27 deletions(-)

diff --git a/benchmark/README.md b/benchmark/README.md
index b5d3296a..343e3ed6 100644
--- a/benchmark/README.md
+++ b/benchmark/README.md
@@ -150,11 +150,19 @@ and render-thread C++ allocation accounting, plus exact publication counts.
 Internal counters/scopes are absent in this mode and are not inferred as zero.
 Keep internal-profiling mode identical within each comparison.
 
+The current workload contract is **version 3**. It stops frame timing and
+allocation measurement before storing harness observations, and removes the
+finish profiler scope and preparation-time lookup from frame-only mode.
+The retained version 2 results are historical evidence with the earlier
+measurement boundary. Do not compare timings across contract versions;
+rebuild both variants with the same version 3 benchmark code for new comparisons.
+
 ### Measurement boundaries
 
 - `benchmark.frame.total_ms` is offscreen frame **wall time**, including
   begin/end-frame, production planning/layout/text/series preparation,
-  recording and `--finish`. It is not application FPS or isolated CPU time.
+  recording and `--finish`. Harness observation storage happens after the
+  timer stops. It is not application FPS or isolated CPU time.
 - `benchmark.frame.submission_ms` includes QRhi begin/end calls, which may
   synchronize. `gpu_finish_ms` is the extra finish call; it is not a GPU timer.
 - Internal named scopes are inclusive and aggregated by full scope name in
@@ -167,6 +175,8 @@ Keep internal-profiling mode identical within each comparison.
   frames and does not claim controlled cold-start performance.
 - Timing runs disable readback. Run `--pixel-checksum` separately on a raster
   backend and compare appropriate stable frames when validating a change.
+  When requested, readback and pixel validation remain inside frame timing
+  and allocation measurement.
   Faster execution alone is not evidence that rendering stayed correct.
 
 The offscreen runner consumes measured value-axis width feedback, as the
diff --git a/benchmark/src/benchmark_window.cpp b/benchmark/src/benchmark_window.cpp
index 3aa8f28b..d113e208 100644
--- a/benchmark/src/benchmark_window.cpp
+++ b/benchmark/src/benchmark_window.cpp
@@ -1082,9 +1082,8 @@ bool Benchmark_rhi_offscreen_runner::render_frame(
     // Plot_widget consumes this feedback too. Keeping the initial width here
     // makes every otherwise static frame miss the settled layout cache.
     m_snapshot->vbar_width_pixels = result.feedback.measured_vbar_width;
-    m_last_prepare_ms = m_profiler.last_series_prepare_ms();
-    if (measured && m_config.internal_profiling) {
-        m_profiler.record_observation("benchmark.planning.time_ms", m_last_prepare_ms);
+    if (m_config.internal_profiling) {
+        m_last_prepare_ms = m_profiler.last_series_prepare_ms();
     }
 
     QRhiReadbackResult readback;
@@ -1101,13 +1100,16 @@ bool Benchmark_rhi_offscreen_runner::render_frame(
         error_message = "measure.end_offscreen_frame: " + frame_op_result_name(end_result);
         return false;
     }
+    double submission_ms = 0.0;
     if (measured) {
-        const double submission_ms = std::chrono::duration<double, std::milli>(
+        submission_ms = std::chrono::duration<double, std::milli>(
             std::chrono::steady_clock::now() - submission_started).count();
-        m_profiler.record_observation("benchmark.frame.submission_ms", submission_ms);
     }
-    if (m_config.finish || (measured && m_config.capture_pixel_checksum)) {
-        VNM_PLOT_PROFILE_SCOPE(&m_profiler, "renderer.frame.finish");
+    double finish_ms = 0.0;
+    const bool finish_frame = m_config.finish || (measured && m_config.capture_pixel_checksum);
+    if (finish_frame) {
+        VNM_PLOT_PROFILE_SCOPE(
+            m_snapshot->config.profiler.get(), "renderer.frame.finish");
         const auto finish_started = std::chrono::steady_clock::now();
         const QRhi::FrameOpResult finish_result = m_rhi->finish();
         if (finish_result != QRhi::FrameOpSuccess) {
@@ -1115,9 +1117,8 @@ bool Benchmark_rhi_offscreen_runner::render_frame(
             return false;
         }
         if (measured) {
-            const double finish_ms = std::chrono::duration<double, std::milli>(
+            finish_ms = std::chrono::duration<double, std::milli>(
                 std::chrono::steady_clock::now() - finish_started).count();
-            m_profiler.record_observation("benchmark.frame.gpu_finish_ms", finish_ms);
         }
     }
     if (measured && m_config.capture_pixel_checksum) {
@@ -1155,23 +1156,34 @@ bool Benchmark_rhi_offscreen_runner::render_frame(
                 }
             }
         }
-        m_profiler.record_observation(
-            "benchmark.frame.pixel_readback_bytes",
-            static_cast<double>(readback.data.size()));
-        m_profiler.record_observation(
-            "benchmark.frame.pixel_checksum_low32",
-            static_cast<double>(checksum & 0xffff'ffffull));
-        m_profiler.record_observation(
-            "benchmark.frame.pixel_nonuniform_count",
-            static_cast<double>(m_pixel_nonuniform_count));
-        m_profiler.record_observation(
-            "benchmark.frame.stack_sum_pixel_count",
-            static_cast<double>(m_stack_sum_pixel_count));
     }
     if (measured) {
+        // Finish frame measurement before storing the harness observations.
+        // Optional readback and pixel validation above remain measured work.
         const Thread_allocation_measurement allocations = allocation_scope.finish();
         const double frame_ms = std::chrono::duration<double, std::milli>(
             std::chrono::steady_clock::now() - frame_started).count();
+        if (m_config.internal_profiling) {
+            m_profiler.record_observation("benchmark.planning.time_ms", m_last_prepare_ms);
+        }
+        m_profiler.record_observation("benchmark.frame.submission_ms", submission_ms);
+        if (finish_frame) {
+            m_profiler.record_observation("benchmark.frame.gpu_finish_ms", finish_ms);
+        }
+        if (m_config.capture_pixel_checksum) {
+            m_profiler.record_observation(
+                "benchmark.frame.pixel_readback_bytes",
+                static_cast<double>(readback.data.size()));
+            m_profiler.record_observation(
+                "benchmark.frame.pixel_checksum_low32",
+                static_cast<double>(m_pixel_checksum & 0xffff'ffffull));
+            m_profiler.record_observation(
+                "benchmark.frame.pixel_nonuniform_count",
+                static_cast<double>(m_pixel_nonuniform_count));
+            m_profiler.record_observation(
+                "benchmark.frame.stack_sum_pixel_count",
+                static_cast<double>(m_stack_sum_pixel_count));
+        }
         m_profiler.record_observation(
             "benchmark.frame.cpu_allocation_count",
             static_cast<double>(allocations.count));
diff --git a/benchmark/src/main.cpp b/benchmark/src/main.cpp
index 0be57c25..5ca5d776 100644
--- a/benchmark/src/main.cpp
+++ b/benchmark/src/main.cpp
@@ -633,7 +633,7 @@ int main(int argc, char* argv[])
         meta.reproduction["seed"] = std::to_string(config.seed);
         meta.reproduction["series_count"] = std::to_string(config.series_count);
         meta.reproduction["stack_series"] = config.stack_series ? "true" : "false";
-        meta.reproduction["workload_contract_version"] = "2";
+        meta.reproduction["workload_contract_version"] = "3";
         meta.reproduction["append_per_frame"] = std::to_string(config.append_per_frame);
         meta.reproduction["view_motion"] = config.view_motion;
         meta.reproduction["preview_enabled"] = config.preview_enabled ? "true" : "false";
diff --git a/benchmark/tools/run_suite.py b/benchmark/tools/run_suite.py
index 9b362895..bcc9582d 100644
--- a/benchmark/tools/run_suite.py
+++ b/benchmark/tools/run_suite.py
@@ -159,7 +159,7 @@ def normalized_backend(value: str) -> str:
 
 def expected_metadata(case: Case, args: argparse.Namespace) -> dict[str, str]:
     return {
-        "workload_contract_version": "2",
+        "workload_contract_version": "3",
         "data_type": case.data_type.title(),
         "render_style": case.style.title(),
         "series_count": str(case.series),
@@ -200,6 +200,17 @@ def check_metadata(actual: dict[str, Any], expected: dict[str, Any], context: st
         raise BenchmarkError(f"{context} metadata mismatch: {json.dumps(mismatches, sort_keys=True)}")
 
 
+def check_frame_timing_only(payload: dict[str, Any]) -> None:
+    for section in ("scopes", "observations"):
+        entries = payload.get(section, {})
+        if not isinstance(entries, dict):
+            raise BenchmarkError(f"{section} must be an object")
+        for name in entries:
+            if name.startswith("renderer.") or name == PLANNING_METRIC:
+                raise BenchmarkError(
+                    f"frame-timing-only report contains internal {section}: {name}")
+
+
 def validate_run(
     payload: dict[str, Any], case: Case, args: argparse.Namespace,
     command: list[str], directory: Path,
@@ -222,6 +233,8 @@ def validate_run(
     elif actual_backend != normalized_backend(args.graphics_backend):
         raise BenchmarkError(f"graphics backend mismatch: {actual_backend}")
 
+    if args.frame_timing_only:
+        check_frame_timing_only(payload)
     metrics = list(METRICS)
     if not args.frame_timing_only:
         metrics.append(PLANNING_METRIC)
diff --git a/benchmark/tools/test_run_suite.py b/benchmark/tools/test_run_suite.py
index 27bde954..e2c32ab8 100644
--- a/benchmark/tools/test_run_suite.py
+++ b/benchmark/tools/test_run_suite.py
@@ -67,11 +67,25 @@ def test_missing_counter_is_not_zero(self) -> None:
         with self.assertRaisesRegex(suite.BenchmarkError, "required observation is missing"):
             self.validate()
 
+    def test_timing_only_rejects_internal_scopes_and_observations(self) -> None:
+        for section, name in (
+            ("scopes", "renderer.frame.finish"),
+            ("scopes", "renderer.frame"),
+            ("observations", "renderer.frame.upload.primary_count"),
+            ("observations", suite.PLANNING_METRIC),
+        ):
+            with self.subTest(section=section, name=name):
+                payload = copy.deepcopy(self.payload)
+                payload.setdefault(section, {})[name] = constant_observation(0)
+                with self.assertRaisesRegex(suite.BenchmarkError, "frame-timing-only report contains internal"):
+                    self.validate(payload)
+
     def test_old_contract_wrong_backend_and_readback_are_rejected(self) -> None:
         for key, value in (("workload_contract_version", "1"),
+                           ("workload_contract_version", "2"),
                            ("actual_graphics_backend", "Null"), ("pixel_readback", "true"),
                            ("access_semantics", "conservative")):
-            with self.subTest(key=key):
+            with self.subTest(key=key, value=value):
                 payload = copy.deepcopy(self.payload)
                 payload["metadata"][key] = value
                 with self.assertRaises(suite.BenchmarkError):
diff --git a/benchmark/tools/validate_workloads.py b/benchmark/tools/validate_workloads.py
index 9d48c171..92501091 100644
--- a/benchmark/tools/validate_workloads.py
+++ b/benchmark/tools/validate_workloads.py
@@ -30,7 +30,7 @@ def run(executable: Path, output: Path, *extra: str) -> dict:
         raise RuntimeError("Expected one raw report per run")
     report = json.loads(reports[0].read_text(encoding="utf-8"))
     observations = report["observations"]
-    assert report["metadata"]["workload_contract_version"] == "2"
+    assert report["metadata"]["workload_contract_version"] == "3"
     assert observations["benchmark.frame.output_count"]["total"] == 8
     assert observations["benchmark.frame.total_ms"]["count"] == 8
     assert observations["benchmark.frame.cpu_allocation_count"]["count"] == 8
@@ -83,7 +83,7 @@ def main() -> None:
         outer = run(args.executable, root / "outer", "--frame-timing-only", "--no-preview")
         assert outer["metadata"]["internal_profiling"] == "false"
         assert outer["metadata"]["preview_enabled"] == "false"
-        assert "renderer.frame" not in outer["scopes"]
+        assert not any(name.startswith("renderer.") for name in outer["scopes"])
         assert "renderer.frame.upload.primary_count" not in outer["observations"]
         assert not any(name.startswith("renderer.") for name in outer["observations"])
         assert "benchmark.planning.time_ms" not in outer["observations"]

From ca15d8cea331fb70a923bcb1a8c75ede3493882f Mon Sep 17 00:00:00 2001
From: Ioannis Makris <imak@imak.gr>
Date: Wed, 4 Nov 2026 02:50:59 +0100
Subject: [PATCH 5/5] Leave unavailable cold preparation timing absent [skip
 ci]

---
 benchmark/src/benchmark_window.cpp    | 8 +++++---
 benchmark/tools/run_suite.py          | 4 +++-
 benchmark/tools/test_run_suite.py     | 1 +
 benchmark/tools/validate_workloads.py | 1 +
 4 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/benchmark/src/benchmark_window.cpp b/benchmark/src/benchmark_window.cpp
index d113e208..ba34a099 100644
--- a/benchmark/src/benchmark_window.cpp
+++ b/benchmark/src/benchmark_window.cpp
@@ -1310,9 +1310,11 @@ bool Benchmark_rhi_offscreen_runner::run(std::string& error_message)
         m_profiler.record_observation(
             "benchmark.cold.first_submission_ms",
             m_cold_first_submission_ms);
-        m_profiler.record_observation(
-            "benchmark.cold.series_shader_pipeline_prepare_ms",
-            m_cold_shader_pipeline_prepare_ms);
+        if (m_config.internal_profiling) {
+            m_profiler.record_observation(
+                "benchmark.cold.series_shader_pipeline_prepare_ms",
+                m_cold_shader_pipeline_prepare_ms);
+        }
     }
     m_profiler.record_observation("benchmark.cold.total_ms", m_cold_total_ms);
     m_profiler.record_observation(
diff --git a/benchmark/tools/run_suite.py b/benchmark/tools/run_suite.py
index bcc9582d..a351235e 100644
--- a/benchmark/tools/run_suite.py
+++ b/benchmark/tools/run_suite.py
@@ -206,7 +206,9 @@ def check_frame_timing_only(payload: dict[str, Any]) -> None:
         if not isinstance(entries, dict):
             raise BenchmarkError(f"{section} must be an object")
         for name in entries:
-            if name.startswith("renderer.") or name == PLANNING_METRIC:
+            if name.startswith("renderer.") or name in (
+                PLANNING_METRIC, "benchmark.cold.series_shader_pipeline_prepare_ms",
+            ):
                 raise BenchmarkError(
                     f"frame-timing-only report contains internal {section}: {name}")
 
diff --git a/benchmark/tools/test_run_suite.py b/benchmark/tools/test_run_suite.py
index e2c32ab8..e4430972 100644
--- a/benchmark/tools/test_run_suite.py
+++ b/benchmark/tools/test_run_suite.py
@@ -73,6 +73,7 @@ def test_timing_only_rejects_internal_scopes_and_observations(self) -> None:
             ("scopes", "renderer.frame"),
             ("observations", "renderer.frame.upload.primary_count"),
             ("observations", suite.PLANNING_METRIC),
+            ("observations", "benchmark.cold.series_shader_pipeline_prepare_ms"),
         ):
             with self.subTest(section=section, name=name):
                 payload = copy.deepcopy(self.payload)
diff --git a/benchmark/tools/validate_workloads.py b/benchmark/tools/validate_workloads.py
index 92501091..0b857d19 100644
--- a/benchmark/tools/validate_workloads.py
+++ b/benchmark/tools/validate_workloads.py
@@ -87,6 +87,7 @@ def main() -> None:
         assert "renderer.frame.upload.primary_count" not in outer["observations"]
         assert not any(name.startswith("renderer.") for name in outer["observations"])
         assert "benchmark.planning.time_ms" not in outer["observations"]
+        assert "benchmark.cold.series_shader_pipeline_prepare_ms" not in outer["observations"]
         assert total(outer, "benchmark.ring.published_samples") == 0
 
         for invalid in (["--view-motion", "unknown"],