Spaces:

betterwithage
/

szl-bench-suite

Running

App Files Files Community

betterwithage commited on 13 days ago

Commit

51f42ca

verified ·

1 Parent(s): 462f17e

chore: publish verified SZL bench-plane snapshot

Browse files

Files changed (3) hide show

README.md +35 -7
index.html +386 -82
results.json +26 -18

README.md CHANGED Viewed

@@ -1,17 +1,45 @@
 ---
 title: SZL Bench Suite
 emoji: 📐
-colorFrom: blue
 colorTo: green
 sdk: static
 app_file: index.html
-pinned: true
-short_description: Receipted engine, retrieval, and quantization evidence.
 ---
 # SZL Bench Suite
-This static Space is the public, fail-closed display for independently verified
-engine, retrieval, and quantization receipts. Its publisher binds every result
-to the exact Git revision that supplied it and deploys the complete surface in
-one provider commit.

 ---
 title: SZL Bench Suite
 emoji: 📐
+colorFrom: gray
 colorTo: green
 sdk: static
 app_file: index.html
+pinned: false
+short_description: Receipt-gated engine, retrieval, and quantization evidence
 ---
 # SZL Bench Suite
+This static Space is the consolidated evidence surface for three SZL bench planes:
+- **Engine** — rows admitted from `szl-holdings/frontier-bench` receipts.
+- **Retrieval** — rows admitted from `szl-holdings/retrieval-bench` receipts.
+- **Quantization** — rows admitted from `szl-holdings/quant-curve` receipts.
+The page does not run benchmarks and does not turn demos, fixtures, projections, or
+in-memory harness output into measurements. `results.json` is assembled only after
+the deployment controller independently recomputes each receipt hash and chain,
+checks the pinned source revision, requires an operator-provisioned HMAC on every
+`MEASURED` envelope, uploads with a parent-commit precondition, and verifies immutable
+and public readback.
+`EMPTY_HONEST` means the validated payload contains zero admitted measured rows.
+Local service health and public runtime health require separate evidence.
+`UNAVAILABLE` means the payload could not be fetched or validated;
+it is never displayed as an honest empty result set.
+The existing `BLOCKED` genesis receipts are unsigned and establish integrity continuity,
+not authorship. A measured row is rejected unless its source, workload, raw-artifact
+digests, hardware-evidence digest, machine, time, method, and metrics are authenticated
+with the operator-held key. HMAC authenticates an operator assertion; it is not an
+independent witness that the workload ran. No separate runtime-witness repository is
+claimed until an addressable, independently verifiable witness exists.
+The browser verifies the SHA-256 digest of the exact result bytes and validates the
+exported schema and authentication metadata. HMAC verification occurs in the controller;
+the public page has neither the shared secret nor an independently verifiable signature.
+Sources: [frontier-bench](https://github.com/szl-holdings/frontier-bench) ·
+[retrieval-bench](https://github.com/szl-holdings/retrieval-bench) ·
+[quant-curve](https://github.com/szl-holdings/quant-curve)

index.html CHANGED Viewed

@@ -1,86 +1,390 @@
 <!doctype html>
 <html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <meta name="color-scheme" content="dark">
-    <meta name="theme-color" content="#071411">
-    <meta name="description" content="Receipted SZL engine, retrieval, and quantization evidence.">
-    <title>SZL Bench Suite</title>
-    <link rel="stylesheet" href="style.css">
-    <script src="app.js" defer></script>
-  </head>
-  <body>
-    <a class="skip-link" href="#evidence">Skip to evidence</a>
-    <header class="hero">
-      <nav class="nav" aria-label="Primary">
-        <a class="brand" href="./" aria-label="SZL Bench Suite home">
-          <span class="brand-mark" aria-hidden="true">SZL</span>
-          <span>Bench Suite</span>
-        </a>
-        <a class="source-link" href="https://github.com/szl-holdings/frontier-bench">Source <span aria-hidden="true">↗</span></a>
-      </nav>
-      <div class="hero-grid">
-        <div>
-          <p class="eyebrow">Public evidence surface</p>
-          <h1>Measurements with receipts,<br><span>or no claim at all.</span></h1>
-          <p class="lede">One source-bound view of engine, retrieval, and quantization results. Every displayed row passed its owning verifier before publication.</p>
-        </div>
-        <aside class="proof-card" aria-label="Publication guarantees">
-          <p class="proof-kicker">Publication contract</p>
-          <ul>
-            <li><span aria-hidden="true">✓</span> Exact source revisions</li>
-            <li><span aria-hidden="true">✓</span> Independent receipt verification</li>
-            <li><span aria-hidden="true">✓</span> One atomic provider commit</li>
-          </ul>
-        </aside>
       </div>
-    </header>
-    <main id="evidence">
-      <section class="status-strip" aria-label="Current publication status">
-        <div><span class="status-dot" aria-hidden="true"></span><span id="load-state">Loading verified evidence…</span></div>
-        <dl>
-          <div><dt>Receipts</dt><dd id="receipt-count">—</dd></div>
-          <div><dt>Sources</dt><dd id="source-count">—</dd></div>
-          <div><dt>Evidence through</dt><dd id="published-at">—</dd></div>
-        </dl>
-      </section>
-      <section class="evidence-section" aria-labelledby="evidence-title">
-        <div class="section-heading">
-          <div>
-            <p class="eyebrow">Verified results</p>
-            <h2 id="evidence-title">Three planes. One truth standard.</h2>
-          </div>
-          <p>Empty planes remain visibly empty. BLOCKED, UNAVAILABLE, and unmeasured data are never promoted into benchmark claims.</p>
-        </div>
-        <div class="tabs" role="tablist" aria-label="Benchmark planes">
-          <button id="tab-engine" role="tab" aria-selected="true" aria-controls="panel-engine" tabindex="0" data-plane="engine">Engine <span id="count-engine">0</span></button>
-          <button id="tab-retrieval" role="tab" aria-selected="false" aria-controls="panel-retrieval" tabindex="-1" data-plane="retrieval">Retrieval <span id="count-retrieval">0</span></button>
-          <button id="tab-quant" role="tab" aria-selected="false" aria-controls="panel-quant" tabindex="-1" data-plane="quant">Quantization <span id="count-quant">0</span></button>
-        </div>
-        <div id="panel-engine" class="panel" role="tabpanel" aria-labelledby="tab-engine" data-panel="engine"></div>
-        <div id="panel-retrieval" class="panel" role="tabpanel" aria-labelledby="tab-retrieval" data-panel="retrieval" hidden></div>
-        <div id="panel-quant" class="panel" role="tabpanel" aria-labelledby="tab-quant" data-panel="quant" hidden></div>
-      </section>
-      <section class="provenance" aria-labelledby="provenance-title">
-        <div>
-          <p class="eyebrow">Reproducibility</p>
-          <h2 id="provenance-title">Bound to what actually ran.</h2>
-          <p>The publisher checks out each evidence repository, runs its verifier, and records the exact 40-character revision beside the admitted results.</p>
-        </div>
-        <div id="source-list" class="source-list" aria-live="polite"></div>
-      </section>
-    </main>
-    <footer>
-      <p>SZL Holdings · Truthful systems engineering</p>
-      <p id="deployment-state">Deployment receipt loading…</p>
-    </footer>
-  </body>
 </html>

 <!doctype html>
 <html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="Content-Security-Policy" content="default-src 'none'; connect-src 'self'; style-src 'sha256-pLisQ4+f61i84Ygbh4v8nD9F4v+kDXOqDIHxDMwDHIs='; script-src 'sha256-hFf+d9bE3RDuo3J4aT/K8dcyvZX31R7DzCIN3vP1/l4='; base-uri 'none'; form-action 'none'; object-src 'none'">
+  <meta name="szl-results-sha256" content="f981c7b33aa0ccc24c070c347fe62fc10737f585577b013dfae44148a3781c28">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta name="color-scheme" content="dark">
+  <title>SZL Bench Suite — measured or absent</title>
+  <style>
+    :root {
+      --bg: #081016;
+      --panel: #101b23;
+      --panel2: #0c151c;
+      --line: #263843;
+      --ink: #e5eef3;
+      --dim: #94a9b5;
+      --good: #3de1af;
+      --warn: #f5bc4b;
+      --bad: #ff6f78;
+      --mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+    }
+    * { box-sizing: border-box; }
+    body { margin: 0; background: var(--bg); color: var(--ink); font: 15px/1.55 var(--mono); }
+    .wrap { width: min(1100px, calc(100% - 30px)); margin: 28px auto 44px; }
+    header, .panel, .status { border: 1px solid var(--line); border-radius: 14px; background: var(--panel); }
+    header { padding: 24px; background: linear-gradient(150deg, #11212a, var(--panel2)); }
+    .kicker { color: var(--good); font-size: 12px; letter-spacing: .17em; text-transform: uppercase; }
+    h1 { margin: 6px 0 8px; font-size: clamp(23px, 5vw, 36px); line-height: 1.2; }
+    h2 { margin: 0 0 12px; font-size: 17px; }
+    p { margin: 0; }
+    .sub { max-width: 78ch; color: var(--dim); }
+    .status { display: grid; grid-template-columns: auto 1fr; gap: 14px; align-items: center; margin: 16px 0; padding: 15px 18px; }
+    .badge { border: 1px solid currentColor; border-radius: 999px; padding: 5px 10px; font-weight: 700; white-space: nowrap; }
+    .status.good .badge { color: var(--good); }
+    .status.warn .badge { color: var(--warn); }
+    .status.bad .badge { color: var(--bad); }
+    .status-detail { color: var(--dim); font-size: 13px; overflow-wrap: anywhere; }
+    nav { display: flex; flex-wrap: wrap; gap: 8px; margin: 18px 0; }
+    button { border: 1px solid var(--line); border-radius: 999px; background: var(--panel); color: var(--dim); font: inherit; padding: 9px 15px; cursor: pointer; }
+    button[aria-pressed="true"] { background: var(--good); border-color: var(--good); color: #032018; font-weight: 700; }
+    section[hidden] { display: none; }
+    .panel { padding: 20px; overflow: hidden; }
+    .truth { margin: 14px 0; border-left: 3px solid var(--warn); padding: 10px 13px; color: var(--dim); background: var(--panel2); }
+    .table-wrap { overflow-x: auto; }
+    table { width: 100%; border-collapse: collapse; min-width: 720px; font-size: 13px; }
+    th, td { border: 1px solid var(--line); padding: 9px 10px; text-align: left; vertical-align: top; }
+    th { color: var(--good); background: var(--panel2); }
+    tr.measured td:first-child { border-left: 3px solid var(--good); }
+    tr.empty td { color: var(--dim); text-align: center; padding: 20px; }
+    .links { display: flex; gap: 16px; flex-wrap: wrap; margin-top: 15px; font-size: 13px; }
+    a { color: var(--good); }
+    .provenance { margin-top: 18px; font-size: 12px; color: var(--dim); overflow-wrap: anywhere; }
+    code { color: var(--ink); }
+    footer { margin-top: 22px; text-align: center; color: var(--dim); font-size: 12px; }
+    @media (max-width: 620px) {
+      .wrap { width: min(100% - 20px, 1100px); margin-top: 10px; }
+      header, .panel { padding: 16px; }
+      .status { grid-template-columns: 1fr; }
+    }
+  </style>
+</head>
+<body>
+<main class="wrap">
+  <header>
+    <div class="kicker">SZL Bench Suite · evidence surface</div>
+    <h1>Measured evidence, with an honest empty state.</h1>
+    <p class="sub">Engine, retrieval, and quantization rows appear from a controller-admitted payload whose exact <code>results.json</code> bytes match this page. The browser checks the result schema and authentication metadata; the controller verifies receipt HMACs before publication. This page does not run benchmarks.</p>
+  </header>
+  <div id="status" class="status warn" role="status" aria-live="polite">
+    <span id="status-badge" class="badge">CHECKING</span>
+    <span id="status-detail" class="status-detail">Validating results.json…</span>
+  </div>
+  <nav aria-label="Bench planes">
+    <button type="button" data-target="engine" aria-pressed="true">Engine</button>
+    <button type="button" data-target="retrieval" aria-pressed="false">Retrieval</button>
+    <button type="button" data-target="quant" aria-pressed="false">Quantization</button>
+  </nav>
+  <section id="engine">
+    <div class="panel">
+      <h2>Engine evidence</h2>
+      <div class="truth">Only receipt-backed observations appear here. The current display repository and its API are evidence consumers; they are not proof that an engine workload ran.</div>
+      <div class="table-wrap">
+        <table>
+          <thead><tr><th>Model</th><th>Precision</th><th>Prompt tok/s</th><th>Decode tok/s</th><th>Peak VRAM</th><th>GPU</th><th>Date</th></tr></thead>
+          <tbody data-plane="engine"><tr class="empty"><td colspan="7">Checking evidence payload…</td></tr></tbody>
+        </table>
+      </div>
+      <div class="links"><a href="https://github.com/szl-holdings/frontier-bench">frontier-bench source</a></div>
+    </div>
+  </section>
+  <section id="retrieval" hidden>
+    <div class="panel">
+      <h2>Retrieval evidence</h2>
+      <div class="truth">Rows require a compatible receipt that binds the named method, machine, time, and measured metrics. Hard-coded demo corpora are not silently presented as production evidence.</div>
+      <div class="table-wrap">
+        <table>
+          <thead><tr><th>Corpus</th><th>Method</th><th>nDCG@10</th><th>Recall@100</th><th>MRR</th><th>p50 ms</th><th>GPU</th><th>Date</th></tr></thead>
+          <tbody data-plane="retrieval"><tr class="empty"><td colspan="8">Checking evidence payload…</td></tr></tbody>
+        </table>
+      </div>
+      <div class="links"><a href="https://github.com/szl-holdings/retrieval-bench">retrieval-bench source</a></div>
+    </div>
+  </section>
+  <section id="quant" hidden>
+    <div class="panel">
+      <h2>Quantization evidence</h2>
+      <div class="truth">A plotted point must come from a compatible measured receipt. Synthetic logits, projections, and labels without model-weight and runtime provenance are not admitted.</div>
+      <div class="table-wrap">
+        <table>
+          <thead><tr><th>Model</th><th>Precision</th><th>Perplexity</th><th>Decode tok/s</th><th>Peak VRAM</th><th>GPU</th><th>Date</th></tr></thead>
+          <tbody data-plane="quant"><tr class="empty"><td colspan="7">Checking evidence payload…</td></tr></tbody>
+        </table>
       </div>
+      <div class="links"><a href="https://github.com/szl-holdings/quant-curve">quant-curve source</a></div>
+    </div>
+  </section>
+  <div id="provenance" class="provenance">Source and receipt provenance unavailable until results.json validates.</div>
+  <footer>Hash chains establish continuity; admitted MEASURED rows also require the operator-held HMAC key. That authenticates an operator assertion, not independent execution. <span id="stamp"></span></footer>
+</main>
+<script>
+(() => {
+  'use strict';
+  const planes = ['engine', 'retrieval', 'quant'];
+  const sourcePins = {
+    engine: {repo: 'frontier-bench', revision: '8b1a3ecb5b567b7836f1d9242694722d316e241c', genesis: 'de352dd39bc106b2d64f8f4cad536e4a26317da6c38d64e282dcb107ab179c37'},
+    retrieval: {repo: 'retrieval-bench', revision: 'ca61ce3f294db1b6deca9e0734c5605e6f58a01b', genesis: 'dff9bc08a2b4cfed07337b8eb31ca7e6382f4a9da87314cc0e328a89fb89ab06'},
+    quant: {repo: 'quant-curve', revision: '3710a43d2566ea1bf820f5687aad07d3de8ea769', genesis: 'cc56e0f6efe1479dd3daccc23d4dabcc0d78de079dac39509f5e4e0777143c0a'}
+  };
+  const columns = {
+    engine: ['model', 'precision', 'prompt_tps', 'decode_tps', 'peak_vram_gb'],
+    retrieval: ['corpus', 'method', 'ndcg10', 'recall100', 'mrr', 'p50_ms'],
+    quant: ['model', 'precision', 'perplexity', 'decode_tps', 'peak_vram_gb']
+  };
+  const spans = {engine: 7, retrieval: 8, quant: 7};
+  const hash64 = /^[0-9a-f]{64}$/;
+  const timestamp = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
+  const artifactName = /^[A-Za-z0-9._/-]{1,128}$/;
+  const expectedDigest = document.querySelector('meta[name="szl-results-sha256"]')?.content || '';
+  const status = document.getElementById('status');
+  const badge = document.getElementById('status-badge');
+  const detail = document.getElementById('status-detail');
+  document.querySelectorAll('nav button').forEach(button => {
+    button.addEventListener('click', () => {
+      document.querySelectorAll('nav button').forEach(item => item.setAttribute('aria-pressed', String(item === button)));
+      planes.forEach(plane => { document.getElementById(plane).hidden = plane !== button.dataset.target; });
+    });
+  });
+  function setStatus(kind, label, message) {
+    status.className = `status ${kind}`;
+    badge.textContent = label;
+    detail.textContent = message;
+  }
+  function setEmptyRow(plane, message) {
+    const body = document.querySelector(`tbody[data-plane="${plane}"]`);
+    body.replaceChildren();
+    const row = document.createElement('tr');
+    row.className = 'empty';
+    const cell = document.createElement('td');
+    cell.colSpan = spans[plane];
+    cell.textContent = message;
+    row.appendChild(cell);
+    body.appendChild(row);
+  }
+  function unavailable(reason) {
+    setStatus('bad', 'UNAVAILABLE', reason);
+    planes.forEach(plane => setEmptyRow(plane, 'UNAVAILABLE — results payload was not admitted.'));
+    document.getElementById('provenance').textContent = 'No result or empty-state claim is displayed because results.json could not be validated.';
+    document.getElementById('stamp').textContent = 'results.json unavailable';
+  }
+  function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+  }
+  function exactKeys(value, expected) {
+    if (!isObject(value)) return false;
+    const actual = Object.keys(value).sort();
+    const wanted = [...expected].sort();
+    return actual.length === wanted.length && actual.every((key, index) => key === wanted[index]);
+  }
+  function boundedText(value, limit = 512) {
+    return typeof value === 'string' && value.trim().length > 0 && [...value].length <= limit;
+  }
+  function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+  }
+  function validTime(value) {
+    if (typeof value !== 'string' || value.length > 64 || !timestamp.test(value) || Number(value.slice(0, 4)) < 1) return false;
+    const parsed = new Date(value);
+    return Number.isFinite(parsed.getTime()) && parsed.toISOString().slice(0, 19) === value.slice(0, 19);
+  }
+  function validHash(value) {
+    return typeof value === 'string' && hash64.test(value);
+  }
+  function validMetrics(plane, metrics) {
+    if (!isObject(metrics)) return false;
+    if (plane === 'engine') {
+      return exactKeys(metrics, ['model', 'precision', 'prompt_tps', 'decode_tps', 'peak_vram_gb']) &&
+        boundedText(metrics.model) && boundedText(metrics.precision) &&
+        finite(metrics.prompt_tps) && metrics.prompt_tps >= 0 &&
+        finite(metrics.decode_tps) && metrics.decode_tps >= 0 &&
+        finite(metrics.peak_vram_gb) && metrics.peak_vram_gb >= 0;
+    }
+    if (plane === 'retrieval') {
+      return exactKeys(metrics, ['corpus', 'method', 'ndcg10', 'recall100', 'mrr', 'p50_ms']) &&
+        boundedText(metrics.corpus) && boundedText(metrics.method) &&
+        finite(metrics.ndcg10) && metrics.ndcg10 >= 0 && metrics.ndcg10 <= 1 &&
+        finite(metrics.recall100) && metrics.recall100 >= 0 && metrics.recall100 <= 1 &&
+        finite(metrics.mrr) && metrics.mrr >= 0 && metrics.mrr <= 1 &&
+        finite(metrics.p50_ms) && metrics.p50_ms >= 0;
+    }
+    return plane === 'quant' &&
+      exactKeys(metrics, ['model', 'precision', 'perplexity', 'decode_tps', 'peak_vram_gb']) &&
+      boundedText(metrics.model) && boundedText(metrics.precision) &&
+      finite(metrics.perplexity) && metrics.perplexity > 0 &&
+      finite(metrics.decode_tps) && metrics.decode_tps >= 0 &&
+      finite(metrics.peak_vram_gb) && metrics.peak_vram_gb >= 0;
+  }
+  function validRow(row, sources) {
+    if (!exactKeys(row, ['plane', 'machine', 'measured_at', 'method', 'metrics', 'receipt', 'source_revision', 'workload', 'artifacts', 'hardware_evidence_sha256', 'receipt_auth'])) return false;
+    if (!planes.includes(row.plane) || row.source_revision !== sources[row.plane].revision) return false;
+    if (!exactKeys(row.machine, ['cpu', 'ram_gb', 'gpu']) ||
+        row.machine.cpu !== 'i9-14900HX' || row.machine.ram_gb !== 128 || row.machine.gpu !== 'RTX 4000 Ada 20GB') return false;
+    if (!boundedText(row.method, 1024) || !validTime(row.measured_at) || !validHash(row.receipt) ||
+        !validHash(row.hardware_evidence_sha256) || !validMetrics(row.plane, row.metrics)) return false;
+    if (!exactKeys(row.workload, ['model_revision', 'data_revision', 'configuration_sha256']) ||
+        !boundedText(row.workload.model_revision) || !boundedText(row.workload.data_revision) ||
+        !validHash(row.workload.configuration_sha256)) return false;
+    if (!isObject(row.artifacts) || Object.keys(row.artifacts).length < 1 || Object.keys(row.artifacts).length > 64 ||
+        !Object.entries(row.artifacts).every(([name, digest]) => artifactName.test(name) && validHash(digest))) return false;
+    return exactKeys(row.receipt_auth, ['alg', 'key_id']) && row.receipt_auth.alg === 'hmac-sha256' &&
+      row.receipt_auth.key_id === 'szl-bench-node-hmac-v1';
+  }
+  function validate(data) {
+    if (!exactKeys(data, ['schema_version', 'generated_at', 'data_state', 'count', 'results_sha256', 'sources', 'results'])) throw new Error('top-level payload fields do not match the contract');
+    if (data.schema_version !== 'szl-bench-results/v2') throw new Error('unsupported or missing schema_version');
+    if (!validTime(data.generated_at)) throw new Error('generated_at is invalid');
+    if (!Array.isArray(data.results)) throw new Error('results is not an array');
+    if (!Number.isInteger(data.count) || data.count < 0 || data.count > planes.length * 10000 || data.count !== data.results.length) throw new Error('count does not equal bounded results length');
+    if (!validHash(data.results_sha256)) throw new Error('results_sha256 is missing or malformed');
+    if (!exactKeys(data.sources, planes)) throw new Error('sources does not contain the exact three planes');
+    for (const plane of planes) {
+      const source = data.sources[plane];
+      const pin = sourcePins[plane];
+      if (!exactKeys(source, ['repo', 'revision', 'genesis', 'receipt_count', 'receipt_head', 'integrity']) ||
+          source.repo !== pin.repo || source.revision !== pin.revision || source.genesis !== pin.genesis ||
+          !Number.isInteger(source.receipt_count) || source.receipt_count < 1 || source.receipt_count > 10000 ||
+          !validHash(source.receipt_head) ||
+          (source.receipt_count === 1 && source.receipt_head !== source.genesis) ||
+          !['VERIFIED_UNSIGNED_EMPTY_CHAIN', 'VERIFIED_CHAIN_AND_HMAC_MEASUREMENTS'].includes(source.integrity)) {
+        throw new Error(`invalid ${plane} source provenance`);
+      }
+    }
+    if (!data.results.every(row => validRow(row, data.sources))) throw new Error('one or more result rows violate the admitted schema');
+    if (new Set(data.results.map(row => row.receipt)).size !== data.results.length) throw new Error('duplicate exported receipt');
+    for (const plane of planes) {
+      const measuredCount = data.results.filter(row => row.plane === plane).length;
+      const source = data.sources[plane];
+      const integrity = measuredCount ? 'VERIFIED_CHAIN_AND_HMAC_MEASUREMENTS' : 'VERIFIED_UNSIGNED_EMPTY_CHAIN';
+      if (source.integrity !== integrity || source.receipt_count < measuredCount + 1) throw new Error(`contradictory ${plane} source integrity or receipt count`);
+    }
+    const expected = data.results.length ? 'MEASURED' : 'EMPTY_HONEST';
+    if (data.data_state !== expected) throw new Error('data_state contradicts result count');
+    return data;
+  }
+  function valueText(value) {
+    if (value === null || value === undefined || value === '') return '—';
+    return typeof value === 'object' ? JSON.stringify(value) : String(value);
+  }
+  function render(data) {
+    for (const plane of planes) {
+      const rows = data.results.filter(row => row.plane === plane);
+      if (!rows.length) {
+        setEmptyRow(plane, 'EMPTY_HONEST — no compatible MEASURED receipt has been admitted.');
+        continue;
+      }
+      const body = document.querySelector(`tbody[data-plane="${plane}"]`);
+      body.replaceChildren();
+      for (const item of rows) {
+        const row = document.createElement('tr');
+        row.className = 'measured';
+        row.title = `receipt ${item.receipt} · source ${item.source_revision}`;
+        for (const key of columns[plane]) {
+          const cell = document.createElement('td');
+          cell.textContent = valueText(item.metrics[key]);
+          row.appendChild(cell);
+        }
+        const gpu = document.createElement('td');
+        gpu.textContent = item.machine.gpu;
+        row.appendChild(gpu);
+        const date = document.createElement('td');
+        date.textContent = item.measured_at.slice(0, 10);
+        row.appendChild(date);
+        body.appendChild(row);
+      }
+    }
+    const isMeasured = data.data_state === 'MEASURED';
+    setStatus(isMeasured ? 'good' : 'warn', data.data_state, `${data.count} admitted row(s) · generated ${data.generated_at} · digest ${data.results_sha256}`);
+    const sourceText = planes.map(plane => {
+      const source = data.sources[plane];
+      return `${plane}: ${source.repo}@${source.revision.slice(0, 12)} · chain ${source.receipt_head.slice(0, 12)} · ${source.integrity}`;
+    }).join(' | ');
+    document.getElementById('provenance').textContent = sourceText;
+    document.getElementById('stamp').textContent = `results.json ${data.results_sha256.slice(0, 12)}`;
+  }
+  async function sha256Hex(bytes) {
+    if (!globalThis.crypto?.subtle) throw new Error('Web Crypto SHA-256 is unavailable');
+    const digest = await crypto.subtle.digest('SHA-256', bytes);
+    return [...new Uint8Array(digest)].map(byte => byte.toString(16).padStart(2, '0')).join('');
+  }
+  async function readBoundedBody(response, maxBytes) {
+    if (!response.body || typeof response.body.getReader !== 'function') throw new Error('streaming response bodies are unavailable');
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+      while (true) {
+        const {done, value} = await reader.read();
+        if (done) break;
+        if (!(value instanceof Uint8Array)) throw new Error('results.json returned an invalid stream chunk');
+        total += value.byteLength;
+        if (total > maxBytes) {
+          await reader.cancel('results.json size limit exceeded');
+          throw new Error('results.json exceeds 4 MiB');
+        }
+        chunks.push(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return bytes;
+  }
+  async function load() {
+    if (!hash64.test(expectedDigest)) throw new Error('page lacks a finalized results digest');
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 10000);
+    try {
+      const response = await fetch('results.json', {cache: 'no-store', redirect: 'error', credentials: 'omit', signal: controller.signal});
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      if (!(response.headers.get('content-type') || '').toLowerCase().includes('application/json')) throw new Error('wrong results.json content type');
+      const lengthHeader = response.headers.get('content-length');
+      if (lengthHeader !== null) {
+        const declaredLength = Number(lengthHeader);
+        if (!Number.isInteger(declaredLength) || declaredLength < 0) throw new Error('results.json has an invalid content length');
+        if (declaredLength > 4194304) throw new Error('results.json exceeds 4 MiB');
+      }
+      const bytes = await readBoundedBody(response, 4194304);
+      if ((await sha256Hex(bytes)) !== expectedDigest) throw new Error('raw results.json digest does not match this page');
+      const text = new TextDecoder('utf-8', {fatal: true}).decode(bytes);
+      return validate(JSON.parse(text));
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  load().then(render).catch(error => unavailable(`results.json validation failed: ${error.message}`));
+})();
+</script>
+</body>
 </html>

results.json CHANGED Viewed

@@ -1,26 +1,34 @@
 {
   "count": 0,
   "generated_at": "2026-09-04T02:15:00Z",
   "results": [],
-  "schema": "szl.bench-suite.results/v1",
-  "sources": [
-    {
-      "plane": "engine",
-      "repository": "szl-holdings/frontier-bench",
-      "revision": "8b1a3ecb5b567b7836f1d9242694722d316e241c",
-      "verified_results_sha256": "c06271cef9397d0d88ea0cb7f28264a3a79f8711283edfc8b1d86b99addcac4c"
     },
-    {
-      "plane": "retrieval",
-      "repository": "szl-holdings/retrieval-bench",
-      "revision": "ca61ce3f294db1b6deca9e0734c5605e6f58a01b",
-      "verified_results_sha256": "c06271cef9397d0d88ea0cb7f28264a3a79f8711283edfc8b1d86b99addcac4c"
     },
-    {
-      "plane": "quant",
-      "repository": "szl-holdings/quant-curve",
-      "revision": "3710a43d2566ea1bf820f5687aad07d3de8ea769",
-      "verified_results_sha256": "c06271cef9397d0d88ea0cb7f28264a3a79f8711283edfc8b1d86b99addcac4c"
     }
-  ]
 }

 {
   "count": 0,
+  "data_state": "EMPTY_HONEST",
   "generated_at": "2026-09-04T02:15:00Z",
   "results": [],
+  "results_sha256": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+  "schema_version": "szl-bench-results/v2",
+  "sources": {
+    "engine": {
+      "genesis": "de352dd39bc106b2d64f8f4cad536e4a26317da6c38d64e282dcb107ab179c37",
+      "integrity": "VERIFIED_UNSIGNED_EMPTY_CHAIN",
+      "receipt_count": 1,
+      "receipt_head": "de352dd39bc106b2d64f8f4cad536e4a26317da6c38d64e282dcb107ab179c37",
+      "repo": "frontier-bench",
+      "revision": "8b1a3ecb5b567b7836f1d9242694722d316e241c"
     },
+    "quant": {
+      "genesis": "cc56e0f6efe1479dd3daccc23d4dabcc0d78de079dac39509f5e4e0777143c0a",
+      "integrity": "VERIFIED_UNSIGNED_EMPTY_CHAIN",
+      "receipt_count": 1,
+      "receipt_head": "cc56e0f6efe1479dd3daccc23d4dabcc0d78de079dac39509f5e4e0777143c0a",
+      "repo": "quant-curve",
+      "revision": "3710a43d2566ea1bf820f5687aad07d3de8ea769"
     },
+    "retrieval": {
+      "genesis": "dff9bc08a2b4cfed07337b8eb31ca7e6382f4a9da87314cc0e328a89fb89ab06",
+      "integrity": "VERIFIED_UNSIGNED_EMPTY_CHAIN",
+      "receipt_count": 1,
+      "receipt_head": "dff9bc08a2b4cfed07337b8eb31ca7e6382f4a9da87314cc0e328a89fb89ab06",
+      "repo": "retrieval-bench",
+      "revision": "ca61ce3f294db1b6deca9e0734c5605e6f58a01b"
     }
+  }
 }