hotfix: head-lag Solana opens on First to report, 1 ms floor, 30 s presence ratio (cherry-picks) (#2393)

* bench spec: optional chart block (min_range, default_range, window_label) for daily-cadence benches (#2364)

perp-daily-volume moves once per UTC day, so 1h/6h/24h drew one point at
"now" and the ledger said "(24h)" for a closed-day figure. The chart now
hides ranges below min_range, opens on default_range and the ledger's
base window reads "last closed day".

Claude-Session: https://claude.ai/code/session_01HJgbZCqjR4nvCfcJSzofbw

Co-authored-by: Flotapponnier <florent@mobula.io>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
(cherry picked from commit f9e4360)

* head-lag: Solana opens on First to report; leader lag floored at 1 ms; success ratio on the real 30 s scrape (#2392)

- spec chart.default_panel_by_chain: a chain tab can open on a metric
  panel; Solana opens on First to report, Base keeps the head lag view.
  A ?view= in the URL still wins on first paint.
- The site drops rows whose headline is exactly 0 (Singapore: Mobula won
  every race and vanished from the ranked chart); the race lag is now
  floored at 1 ms, below the tie window.
- Presence ratio divided by 5,760 assumed a 15 s scrape; the store is
  scraped every 30 s, so every provider capped at 49.5 %. Now 2,880.

Claude-Session: https://claude.ai/code/session_01HJgbZCqjR4nvCfcJSzofbw

Co-authored-by: Flotapponnier <florent@mobula.io>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
(cherry picked from commit d1646ef)

---------

Co-authored-by: Flotapponnier <florent@mobula.io>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: 3 people

benchmarks/aggregator-head-lag.yml

@@ -72,8 +72,8 @@ methodology:
   - "Regions: us-east, eu-west, sgp. Cross-region median reported in the headline."
   - "Reference on Base: the sequencer's flashblock preconfirmation stream, held by us in every region. A Base block becomes queryable about 0.36 s after the timestamp it carries, while flashblocks publish every 200 ms inside the 2 s interval, so that timestamp is not the moment a trade becomes knowable."
   - "Base emissions we cannot match to a flashblock are dropped rather than measured against a different ruler. Measuring against the block timestamp charged a provider reading preconfirmations with a negative lag, and described the chain's stamping convention rather than the provider's pipeline."
-  - "Metric: gauge `head_lag_seconds`, sampled every 15 seconds. Aggregated over the 24-hour window using `quantile_over_time`."
-  - "Success rate: presence ratio. Share of expected sampling slots where a value was actually emitted (5,760 expected per provider per day at the 15s cadence). 100% means the aggregator's feed was reachable for the full window."
+  - "Metric: gauge `head_lag_seconds`, scraped every 30 seconds. Aggregated over the 24-hour window using `quantile_over_time`."
+  - "Success rate: presence ratio. Share of expected sampling slots where a value was actually emitted (2,880 expected per provider per day at the 30 s scrape). 100% means the aggregator's feed was reachable for the full window."
   - "Cardinality: 4 aggregators × 4 chains × 3 regions = 48 active series."
   - "Probe placement: the three probes run in their named regions on Railway (europe-west4, us-east4, asia-southeast1). Until 2026-09-15 all three ran in asia-southeast1 under regional labels; region columns before that date are three Singapore vantage points."
 
@@ -94,6 +94,10 @@ source: https://github.com/ChainBench/OpenChainBench/tree/main/harnesses/aggrega
 # reported first over the last 24 h, our node reference included as a
 # competitor. The avg by (aggregator) collapses chain x region series the
 # way the headline queries do; the chain filter narrows it per chain.
+chart:
+  default_panel_by_chain:
+    solana: first_share
+
 metric_panels:
   - id: first_share
     label: First to report
@@ -188,7 +192,7 @@ providers:
       p90: avg by (aggregator) (quantile_over_time(0.90, head_lag_seconds{aggregator="mobula"}[24h])) * 1000
       p99: avg by (aggregator) (quantile_over_time(0.99, head_lag_seconds{aggregator="mobula"}[24h])) * 1000
       mean: avg by (aggregator) (avg_over_time(head_lag_seconds{aggregator="mobula"}[24h])) * 1000
-      success: clamp_max(avg by (aggregator) (count_over_time(head_lag_seconds{aggregator="mobula"}[24h]) / 5760), 1)
+      success: clamp_max(avg by (aggregator) (count_over_time(head_lag_seconds{aggregator="mobula"}[24h]) / 2880), 1)
       sample_size: sum(count_over_time(head_lag_seconds{aggregator="mobula"}[24h]))
       # Hybrid `unless` guard: drop the sample when the gauge saw no
       # fresh event in the last 15 min AND we have enough scrapes in
@@ -226,7 +230,7 @@ providers:
       p90: avg by (aggregator) (quantile_over_time(0.90, head_lag_seconds{aggregator="codex"}[24h])) * 1000
       p99: avg by (aggregator) (quantile_over_time(0.99, head_lag_seconds{aggregator="codex"}[24h])) * 1000
       mean: avg by (aggregator) (avg_over_time(head_lag_seconds{aggregator="codex"}[24h])) * 1000
-      success: clamp_max(avg by (aggregator) (count_over_time(head_lag_seconds{aggregator="codex"}[24h]) / 5760), 1)
+      success: clamp_max(avg by (aggregator) (count_over_time(head_lag_seconds{aggregator="codex"}[24h]) / 2880), 1)
       sample_size: sum(count_over_time(head_lag_seconds{aggregator="codex"}[24h]))
       series: avg_over_time(head_lag_seconds{aggregator="codex"}[1h]) * 1000 unless (changes(head_lag_seconds{aggregator="codex"}[15m]) == 0 and count_over_time(head_lag_seconds{aggregator="codex"}[15m]) > 5 and on(chain, region) sum by (chain, region) (changes(head_lag_seconds{}[15m])) > 5 and on(aggregator, region) avg_over_time(ws_connected{aggregator="codex", chain=""}[15m]) > 0.8)
       live_activity: sum(changes(head_lag_seconds{aggregator="codex"}[15m]))
@@ -250,7 +254,7 @@ providers:
       p90: avg by (aggregator) (quantile_over_time(0.90, head_lag_seconds{aggregator="geckoterminal"}[24h])) * 1000
       p99: avg by (aggregator) (quantile_over_time(0.99, head_lag_seconds{aggregator="geckoterminal"}[24h])) * 1000
       mean: avg by (aggregator) (avg_over_time(head_lag_seconds{aggregator="geckoterminal"}[24h])) * 1000
-      success: clamp_max(avg by (aggregator) (count_over_time(head_lag_seconds{aggregator="geckoterminal"}[24h]) / 5760), 1)
+      success: clamp_max(avg by (aggregator) (count_over_time(head_lag_seconds{aggregator="geckoterminal"}[24h]) / 2880), 1)
       sample_size: sum(count_over_time(head_lag_seconds{aggregator="geckoterminal"}[24h]))
       series: avg_over_time(head_lag_seconds{aggregator="geckoterminal"}[1h]) * 1000 unless (changes(head_lag_seconds{aggregator="geckoterminal"}[15m]) == 0 and count_over_time(head_lag_seconds{aggregator="geckoterminal"}[15m]) > 5 and on(chain, region) sum by (chain, region) (changes(head_lag_seconds{}[15m])) > 5)
       live_activity: sum(changes(head_lag_seconds{aggregator="geckoterminal"}[15m]))

harnesses/aggregator-head-lag/cmd/script/race.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"math"
 	"sort"
 	"sync"
 	"time"
@@ -94,6 +95,15 @@ var race = &raceBook{
 	participants: map[string]map[string]bool{},
 }
 
+// raceLagSeconds floors the published lag at 1 ms. The first feed is 0 by
+// definition, but the site drops rows whose headline reads exactly zero
+// (a zero p50 means "no measurement" everywhere else), which hid the
+// leader on the Singapore tab where Mobula won every race. One
+// millisecond is below the tie window and reads as "first".
+func raceLagSeconds(d time.Duration) float64 {
+	return math.Max(d.Seconds(), 0.001)
+}
+
 func raceKey(chain, region, hash string) string {
 	return chain + "|" + region + "|" + hash
 }
@@ -122,7 +132,7 @@ func (b *raceBook) observe(aggregator, chain, region, hash string, at time.Time,
 		// Late arrival: it lost, and its lag is against the recorded first.
 		b.note(chain, region, aggregator)
 		if raceChains[chain] {
-			RecordHeadLag(aggregator, chain, lagBlocks, at.Sub(e.t0).Seconds(), region, hash)
+			RecordHeadLag(aggregator, chain, lagBlocks, raceLagSeconds(at.Sub(e.t0)), region, hash)
 		}
 		return
 	}
@@ -196,7 +206,7 @@ func (b *raceBook) closeLocked(e *raceEntry, k string) {
 			headLagFirst.WithLabelValues(o.aggregator, e.chain, e.region).Inc()
 		}
 		if o.aggregator != "reference" && raceChains[e.chain] {
-			RecordHeadLag(o.aggregator, e.chain, o.lagBlocks, delta.Seconds(), e.region, hash)
+			RecordHeadLag(o.aggregator, e.chain, o.lagBlocks, raceLagSeconds(delta), e.region, hash)
 		}
 	}
 	if !refSeen {

src/components/benchmark-body.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { useSearchParams } from "next/navigation";
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { Benchmark } from "@/types/benchmark";
 import { liveResults } from "@/lib/provider-filters";
 import { matchesChainSlug } from "@/lib/chain-aliases";
@@ -304,6 +304,27 @@ export function BenchmarkBody({
   const fallbackKind = kindOptions[0]?.value ?? null;
   const fallbackVenue = venueOptions[0]?.value ?? null;
   const effectiveChain = chainOptions.length > 0 ? (chain ?? fallbackChain) : null;
+
+  // Per-chain default view (spec chart.default_panel_by_chain). Applied
+  // when the reader lands without ?view= and each time the chain tab
+  // changes, so Solana on aggregator-head-lag opens on First to report
+  // while Base keeps the head lag headline. A ?view= in the URL wins on
+  // first paint; after that the chain tab drives it like a fresh visit.
+  const defaultPanelByChain = Object.values(variants)[0]?.chart?.defaultPanelByChain;
+  const urlViewPinned = useRef(Boolean(urlView));
+  useEffect(() => {
+    if (!defaultPanelByChain) return;
+    if (urlViewPinned.current) {
+      urlViewPinned.current = false;
+      return;
+    }
+    const want = effectiveChain ? defaultPanelByChain[effectiveChain] ?? null : null;
+    const seedPanels = Object.values(variants)[0]?.metricPanels ?? [];
+    const valid = want && seedPanels.some((p) => p.id === want) ? want : null;
+    // eslint-disable-next-line react-hooks/set-state-in-effect
+    setActivePanelId(valid);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [effectiveChain]);
   const effectiveRegion = regionOptions.length > 0 ? (region ?? fallbackRegion) : null;
   const effectiveKind = kindOptions.length > 0 ? (kind ?? fallbackKind) : null;
   const effectiveVenue = venueOptions.length > 0 ? (venue ?? fallbackVenue) : null;

src/components/ledger-table.tsx

@@ -157,9 +157,12 @@ export function LedgerTable({
     }
     return colValue(r, col);
   };
+  // A daily-cadence bench relabels the base window ("last closed day"
+  // instead of "24h") via the spec's chart.window_label.
+  const baseWindowLabel = benchmark.chart?.windowLabel ?? "24h";
   const colLabel = (col: LedgerColumn): string => {
     if (!hasWindows) return col.label;
-    const w = windowKey !== "24h" && col.windows?.[windowKey] ? windowKey : "24h";
+    const w = windowKey !== "24h" && col.windows?.[windowKey] ? windowKey : baseWindowLabel;
     return `${col.label} (${w})`;
   };
 
@@ -361,6 +364,7 @@ export function LedgerTable({
             <button
               key={w}
               type="button"
+              title={w === "24h" && baseWindowLabel !== "24h" ? baseWindowLabel : undefined}
               onClick={() => setWindowKey(w)}
               className={[
                 "rounded px-2.5 py-1 text-[11px] font-sans tabular uppercase tracking-[0.1em] font-medium transition-colors",
@@ -369,7 +373,7 @@ export function LedgerTable({
                   : "text-ink-muted hover:text-ink hover:bg-paper-soft",
               ].join(" ")}
             >
-              {w}
+              {w === "24h" && baseWindowLabel !== "24h" ? baseWindowLabel : w}
             </button>
           ))}
         </div>

src/components/time-series-chart/index.tsx

@@ -119,7 +119,14 @@ export function TimeSeriesChart({
   longRangeDisabledTitle,
   onAvailableRangesChange,
 }: Props) {
-  const [rangeLocal, setRangeLocal] = useState<Range>("24h");
+  // Daily-cadence benches (spec `chart` block) hide sub-day ranges,
+  // which would show one point at "now", and open on a longer window.
+  const minRange: Range = benchmark.chart?.minRange ?? "1h";
+  const rangeOrder: Range[] = ["1h", "6h", "24h", "7d", "30d", "90d", "180d", "1y", "all"];
+  const rangeAllowed = (r: Range) => rangeOrder.indexOf(r) >= rangeOrder.indexOf(minRange);
+  const [rangeLocal, setRangeLocal] = useState<Range>(
+    benchmark.chart?.defaultRange ?? (rangeAllowed("24h") ? "24h" : minRange),
+  );
   const range = rangeProp ?? rangeLocal;
   const setRange = (next: Range) => {
     if (onRangeChange) onRangeChange(next);
@@ -413,12 +420,14 @@ export function TimeSeriesChart({
   useEffect(() => {
     if (panelActive) return;
     /* eslint-disable react-hooks/set-state-in-effect */
-    if (range === "7d" && lazySeries7d !== null && !seriesHasData(lazySeries7d)) setRange("24h");
-    if (range === "30d" && lazySeries30d !== null && !seriesHasData(lazySeries30d)) setRange("24h");
+    const base: Range = rangeAllowed("24h") ? "24h" : minRange;
+    if (range === "7d" && lazySeries7d !== null && !seriesHasData(lazySeries7d) && base !== "7d") setRange(base);
+    if (range === "30d" && lazySeries30d !== null && !seriesHasData(lazySeries30d) && base !== "30d")
+      setRange(has7d && rangeAllowed("7d") ? "7d" : base);
     if (range === "90d" && lazySeries90d !== null && Object.keys(lazySeries90d).length === 0)
-      setRange(has30d ? "30d" : "24h");
+      setRange(has30d ? "30d" : base);
     if (range === "1y" && lazySeries1y !== null && Object.keys(lazySeries1y).length === 0)
-      setRange(has90d ? "90d" : "24h");
+      setRange(has90d ? "90d" : base);
     /* eslint-enable react-hooks/set-state-in-effect */
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [range, panelActive, lazySeries7d, lazySeries30d, lazySeries90d, lazySeries1y]);
@@ -621,6 +630,7 @@ export function TimeSeriesChart({
       <div className="mb-4 flex flex-wrap items-center justify-between gap-3" data-chart-export-omit="true">
         <div className="flex flex-wrap items-center gap-1">
           {RANGES.map((r) => {
+            if (!rangeAllowed(r)) return null;
             // Hide entirely once we have confirmed there's no data for this range.
             if (r === "7d" && lazySeries7d !== null && !has7d) return null;
             if (r === "30d" && lazySeries30d !== null && !has30d) return null;

src/lib/materialize/load.ts

@@ -31,6 +31,24 @@ import {
 const SPECS_DIR =
   process.env.OCB_SPECS_DIR ?? path.join(process.cwd(), "benchmarks");
 
+/** Camel-cased copy of the spec's optional `chart` block. */
+export function chartFromSpec(spec: {
+  chart?: {
+    min_range?: "24h" | "7d" | "30d";
+    default_range?: "24h" | "7d" | "30d" | "90d" | "1y";
+    window_label?: string;
+    default_panel_by_chain?: Record<string, string>;
+  };
+}): Benchmark["chart"] {
+  if (!spec.chart) return undefined;
+  return {
+    minRange: spec.chart.min_range,
+    defaultRange: spec.chart.default_range,
+    windowLabel: spec.chart.window_label,
+    defaultPanelByChain: spec.chart.default_panel_by_chain,
+  };
+}
+
 /** Side-effect hooks injected by the caller (site: KV snapshot write;
  *  worker: store publish). Keeps this module free of persistence deps. */
 export type LoadHooks = {
@@ -139,6 +157,7 @@ export function buildEditorial(
     panelMainLabel: spec.panel_main_label,
     panelMainDescription: spec.panel_main_description,
     stackedShare: spec.stacked_share,
+    chart: chartFromSpec(spec),
     unit: spec.unit,
     higherIsBetter: spec.higher_is_better,
     abstract: spec.abstract,

src/lib/spec-schema.ts

@@ -467,6 +467,33 @@ export const SpecSchema = z
      *  where the relative contribution of each venue over time is the
      *  primary signal. */
     stacked_share: z.boolean().optional(),
+    /**
+     * Chart cadence for benches whose gauges move once a day (closed
+     * UTC-day series such as perp-daily-volume). Sub-day ranges (1h, 6h,
+     * 24h) would render a single point at "now", so `min_range` hides
+     * them and `default_range` opens the chart on a window that holds
+     * data. `window_label` replaces the "24h" suffix on the ledger's
+     * headline columns ("last closed day").
+     */
+    chart: z
+      .object({
+        min_range: z.enum(["24h", "7d", "30d"]).optional(),
+        default_range: z.enum(["24h", "7d", "30d", "90d", "1y"]).optional(),
+        window_label: z.string().min(1).max(24).optional(),
+        /** Metric panel to open on by chain (dimension value -> panel id).
+         *  aggregator-head-lag opens Solana on "first_share": the headline
+         *  there is the lag behind the first feed, so the leader reads 0 and
+         *  the share of trades each feed reported first is the view that
+         *  answers the question. Ignored when the URL carries ?view=. */
+        default_panel_by_chain: z
+          .record(
+            z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/),
+            z.string().regex(/^[a-z][a-z0-9_]*$/),
+          )
+          .optional(),
+      })
+      .strict()
+      .optional(),
     metric_panels: z
       .array(
         z.object({

src/lib/spec.ts

@@ -20,6 +20,7 @@ import type { Spec } from "@/lib/spec-schema";
 import { canonicalChainSlug } from "@/lib/chain-aliases";
 import { renderBenchmarkText } from "@/lib/bench-template";
 import {
+  chartFromSpec,
   draftPlaceholderForSpec,
   filterSig,
   loadSpecsUncached,
@@ -137,6 +138,7 @@ export function overlayEditorial(stored: Benchmark, spec: Spec): Benchmark {
     // worker running a divergent branch (keyed-rpc-robinhood: main is
     // Singapore-only while dev/worker carries the region dims).
     dimensions: spec.dimensions,
+    chart: chartFromSpec(spec) ?? stored.chart,
     // Same source-of-truth rule as dimensions: the live YAML decides
     // the aggregate pin, never the snapshot.
     aggregateFilters: spec.aggregate_filters,

src/types/benchmark.ts

@@ -335,6 +335,16 @@ export type Benchmark = {
   panelMainLabel?: string;
   /** Tooltip of the headline tab in the panel switcher. */
   panelMainDescription?: string;
+  /** Chart cadence hints from the spec's `chart` block: hide sub-day
+   *  ranges, open on a longer window, relabel the "24h" ledger suffix.
+   *  Set for benches whose gauges move once per UTC day. */
+  chart?: {
+    minRange?: "24h" | "7d" | "30d";
+    defaultRange?: "24h" | "7d" | "30d" | "90d" | "1y";
+    windowLabel?: string;
+    /** Chain dimension value -> metric panel id to open on. */
+    defaultPanelByChain?: Record<string, string>;
+  };
   /** When true the bench page renders a stacked bar chart (absolute + %
    *  share over time) below the main chart. Set via `stacked_share: true`
    *  in the bench YAML. Meaningful only for volume-share benches. */