feat(site): show the benchmark version, and mark rows measured by an older one

The engine commit travelled into every row from the first stamped run and
nothing rendered it. "Which version of the benchmark produced this number" was
answerable only by opening the JSON, and the only thing that ever consulted it
was C8 - a build guard that refuses a mixed board and then says nothing when it
passes.

Each row now carries its benchmark version, quiet when it matches the board and
red when it does not, with a tooltip naming both versions and why the difference
matters: numbers from two harnesses are not directly comparable. The footer
states the board's own version so a red pill has something to be compared
against, and counts how many rows are behind it - one red pill in a long table
is easy to miss, and the count is what actually decides whether the board is
safely comparable.

A row with no stamp at all renders "engine unknown" rather than nothing:
implying it matches is worse than saying we cannot tell.

The board's version is the engine of the most recently measured row, which is
the one a re-run moves forward. Test covers current, behind, unstamped, and the
nothing-to-compare case, and was confirmed RED without the flag.

Author: MattJackson

site/app.js

@@ -158,7 +158,40 @@ function measuredBadge(g, now = Date.now()) {
   const stalePill = g.stale
     ? ` <span class="stale-pill" title="This gateway's data has aged past the freshness threshold; re-run it to refresh.">stale</span>`
     : "";
-  return `<span class="measured-at${g.stale ? " stale" : ""}" title="${esc(stampWithAge(g.measured_at, now))}">${esc(rel)}</span>${stalePill}`;
+  return `<span class="measured-at${g.stale ? " stale" : ""}" title="${esc(stampWithAge(g.measured_at, now))}">${esc(rel)}</span>${stalePill}${engineBadge(g)}`;
+}
+
+/* The board's own benchmark version, read defensively: this helper is called from measuredBadge(),
+   which site/test.mjs drives under Node where there is no window and no live state. */
+function boardBenchmarkVersion() {
+  try {
+    return (typeof state !== "undefined" && state.data && state.data.benchmark_version) || null;
+  } catch {
+    return null;
+  }
+}
+
+/* WHICH HARNESS MEASURED THIS ROW.
+   The engine commit already travelled into every row and nothing rendered it, so "which version of
+   the benchmark produced this number" was answerable only by opening the JSON. A row measured by an
+   older engine is not necessarily wrong, but it is not comparable to the rest of the board, and a
+   reader deciding whether to trust a side-by-side needs to see that rather than be told.
+   Current rows show the sha quietly; an older one is red and says what it should have been.
+   Returns "" when the row carries no engine at all AND the board has none either - there is nothing
+   to compare, so a badge would be noise. Pure; covered by site/test.mjs. */
+function engineBadge(g, boardEngine = boardBenchmarkVersion()) {
+  const e = g && g.engine;
+  if (!e) return "";
+  if (!e.sha) {
+    return boardEngine
+      ? ` <span class="engine-pill old" title="This row carries no benchmark version at all: it predates the stamp, so which harness measured it cannot be established. The board is on ${esc(boardEngine.slice(0, 7))}.">engine unknown</span>`
+      : "";
+  }
+  const cls = e.current ? "engine-pill" : "engine-pill old";
+  const title = e.current
+    ? `Measured by benchmark ${e.sha}, which is the version the rest of the board was measured on.`
+    : `Measured by benchmark ${e.sha}, but the board is on ${boardEngine ? boardEngine.slice(0, 7) : "a newer version"}. Numbers from two different harnesses are not directly comparable - re-run this gateway to refresh it.`;
+  return ` <span class="${cls}" title="${esc(title)}">${esc(e.short)}</span>`;
 }
 
 function esc(s) {
@@ -2475,6 +2508,17 @@ function renderStatic() {
   const bits = [];
   if (state.data.hardware) bits.push(`Ran on: ${state.data.hardware}`);
   if (state.data.latest_measured_at) bits.push(`Latest measurement: ${stampWithAge(state.data.latest_measured_at)}`);
+  // WHICH BENCHMARK PRODUCED THIS BOARD. Stated once here so the per-row sha has something to be
+  // compared against: a red row means "not this one", and a reader should not have to infer what
+  // "this one" is. Also counts the rows that are behind it, because one red pill in a long table is
+  // easy to miss and the count is the thing that decides whether the board is safely comparable.
+  if (state.data.benchmark_version) {
+    const behind = (state.data.gateways || []).filter((g) => g.engine && !g.engine.current).length;
+    const short = String(state.data.benchmark_version).slice(0, 7);
+    bits.push(behind
+      ? `Benchmark version: ${short} (${behind} row${behind === 1 ? "" : "s"} measured on an older version)`
+      : `Benchmark version: ${short}`);
+  }
   bits.push(`Site data generated: ${state.data.generated_at ? stampWithAge(state.data.generated_at) : "unknown"}`);
   const rig = rigStamp();
   if (rig) bits.push(rig);
@@ -2919,7 +2963,7 @@ if (NODE) {
   /* Exports for the node smoke test (site/test.mjs). */
   module.exports = {
     newState, encodeUrl, decodeUrl, viewPath, applyFilters,
-    fmtStamp, fmtAge, stampWithAge, measuredBadge,
+    fmtStamp, fmtAge, stampWithAge, measuredBadge, engineBadge,
     drawSweep, niceStep, fmtTick, COLUMN_SETS, columnsFor, PERF_VIEWS, TABLE_VIEWS, VIEW_SORT, LANES, naText, stripRigPaths,
     cellState, matrixCellTip, cellPerfTip, passCell, xlateCell, streamCell, memCell, rssSparkline, hasTranslation, CATEGORIES, DEFAULT_CATEGORY, VIEWS,
     CHOOSER_MODES, chooserCellPerf, chooserDialects, chooserPerfCell, chooserCellStream, chooserStreamCell, chooserHasCell, deltaToPeak, cellPopFull,

site/gen-data.mjs

@@ -765,12 +765,41 @@ const redirects = join(HERE, "_redirects");
 if (existsSync(redirects) && OUT !== HERE) copyFileSync(redirects, join(OUT, "_redirects"));
 
 // ---- emit -------------------------------------------------------------------
+// THE BOARD'S OWN ENGINE, and each row's, surfaced for the reader.
+//
+// The engine commit already travelled into every row inside `rig.engine.commit`; nothing rendered
+// it, so "which harness measured this" was knowable only by opening the JSON. A row measured by an
+// older engine is not necessarily wrong, but it is not comparable to the rest, and a reader deciding
+// whether to trust a comparison needs to see that without being told.
+//
+// The board's version is the engine of the most recently measured row, which is the one a re-run
+// moves forward. A row whose engine differs from it is marked, and the site renders that in red.
+const engineOf = (g) => (g && g.rig && g.rig.engine && g.rig.engine.commit) || null;
+const newestRow = gateways
+  .filter((g) => displayedMeasuredMs(g) > 0)
+  .sort((a, b) => displayedMeasuredMs(b) - displayedMeasuredMs(a))[0];
+const boardEngine = engineOf(newestRow);
+for (const g of gateways) {
+  const sha = engineOf(g);
+  g.engine = sha
+    ? { sha, short: sha.slice(0, 7), current: boardEngine == null || sha === boardEngine }
+    // A row with no engine stamp predates the stamp entirely; saying so is better than implying it
+    // matches, and better than omitting the field so the render site has to guess.
+    : { sha: null, short: null, current: false };
+}
+
 const data = {
   category: "gateways", // which category bundle this is (see CATEGORIES in app.js)
   generated_at: generatedAt,
   hardware,
   // MED-1: the DISPLAYED-number freshness stamp (matrix-preferring), not the max across all suites.
   latest_measured_at: latestDisplayed,
+  // WHICH HARNESS MEASURED THE BOARD, as a thing a reader can see rather than a thing a build guard
+  // knows privately. C8 refuses to publish a board whose columns were measured by different engines,
+  // which is the right call for a ranking - but it made the engine invisible when it passed, so a
+  // reader had no way to tell WHICH harness produced the numbers or whether a row was measured by an
+  // older one. The board states its own engine, and every row states the engine that measured it.
+  benchmark_version: boardEngine,
   repo: "https://github.com/GetBusbar/benchmarking",
   gateways,
   charts,

site/style.css

@@ -606,3 +606,22 @@ td.memcurve.na { color: var(--fg-mute); }
   .site-header h1.brand { font-size: 1.2rem; }
   .tab { padding: .55rem .55rem; font-size: .9rem; }
 }
+
+/* Benchmark version per row. Quiet when the row was measured by the same harness as the rest of the
+   board; red when it was not, because numbers from two harnesses are not comparable and that has to
+   be visible rather than known only to the build guard. */
+.engine-pill {
+  display: inline-block;
+  margin-left: .4rem;
+  padding: 0 .35rem;
+  border-radius: 3px;
+  font: 500 11px/1.6 ui-monospace, SFMono-Regular, Menlo, monospace;
+  color: var(--muted, #6b7280);
+  background: rgba(127, 127, 127, .12);
+  vertical-align: baseline;
+}
+.engine-pill.old {
+  color: #b42318;
+  background: rgba(217, 45, 32, .12);
+  font-weight: 600;
+}

site/test.mjs

@@ -3219,4 +3219,37 @@ test("seal: matching a PACED upstream publishes the value; matching a CAPACITY s
   assert.equal(sealMetric(500, { gated: true, paced: true, flag: false }).value, 500);
   assert.equal(sealMetric(500, { gated: true, flag: false }).value, 500);
 });
+// ---- the benchmark version is visible, and an older one is loud -------------------------------
+// The engine commit travelled into every row from the start and nothing rendered it, so "which
+// version of the benchmark produced this number" was answerable only by opening the JSON. A row
+// measured by an older harness is not necessarily wrong, but it is not comparable to the rest, and
+// that has to be visible rather than known only to the build guard that refuses mixed boards.
+test("benchmark version: current rows are quiet, older rows are marked red with what they should be", () => {
+  const board = "8f2af5ddc8980fce326ef140e4f75de36e8cfc72";
+  const current = { key: "a", measured_at: new Date().toISOString(),
+    engine: { sha: board, short: "8f2af5d", current: true } };
+  const behind = { key: "b", measured_at: new Date().toISOString(),
+    engine: { sha: "dd26a545026be44a0c38589242859138df05b2eb", short: "dd26a54", current: false } };
+
+  const cur = app.engineBadge(current, board);
+  assert.match(cur, /8f2af5d/, "a current row still shows which harness measured it");
+  assert.ok(!/engine-pill old/.test(cur), "and is not flagged");
+
+  const old = app.engineBadge(behind, board);
+  assert.match(old, /engine-pill old/, "a row measured by an older harness must be marked");
+  assert.match(old, /dd26a54/, "showing the version it WAS measured on");
+  assert.match(old, /8f2af5d/, "and the version the board is on, so the reader can see the gap");
+  assert.match(old, /not directly comparable/, "and why that matters");
+
+  // A row with no stamp at all predates the engine stamp entirely. Saying so beats implying it
+  // matches, and beats omitting the badge so the reader assumes it does.
+  const unstamped = app.engineBadge({ key: "c", engine: { sha: null, short: null, current: false } }, board);
+  assert.match(unstamped, /engine unknown/);
+  assert.match(unstamped, /engine-pill old/);
+
+  // Nothing to compare against: no board version and no row version renders nothing rather than an
+  // empty pill.
+  assert.equal(app.engineBadge({ key: "d", engine: { sha: null, short: null, current: false } }, null), "");
+  assert.equal(app.engineBadge({ key: "e" }, board), "", "a row with no engine field at all renders nothing");
+});