Voxel exact tab with the first frozen result, from Scrolls main 1dcab57 (PR #255)

README.md

@@ -26,8 +26,12 @@ On fresh test sites, 91% of snapped PHerc0139 vertices sit within one voxel of t
 1.129 µm scan, against 24% for the published labels.
 
 - **Viewer**: pick a segment and a z plane; orange is the published label, blue the snapped one, gray strokes join
-  matching points. Arrow keys step along the label and through z; `?seg=SEGMENT&z=Z` links to a view.
+  matching points; Animate snap moves each vertex from its published position to its snapped one, slowly. Arrow keys
+  step along the label and through z; `?seg=SEGMENT&z=Z` links to a view.
 - **All segments**: every segment with its share snapped, median move and held-back count.
+- **Voxel exact** (shown once results are published): per scroll, Measured, Certified or Not shown, with the share
+  within 0.5, 1 and 2 voxels, the abstain strata, residual histograms and the controls. `?vx=fixture` previews it on
+  made-up data under a banner.
 - **How it works**: the two methods, how they were measured, the files in each segment folder, and the limits.
 - **Connect your tool**: tested snippets for the dataset, a mesh and the CT.
 

app.js

@@ -10,7 +10,8 @@ const $ = (id) => document.getElementById(id);
 const fmt = (n) => (n == null ? 'n/a' : Number(n).toLocaleString('en-US'));
 const pct = (a, b) => (b ? `${(100 * a / b).toFixed(1)}%` : 'n/a');
 
-const S = { index: [], seg: null, view: null, rows: null, plane: 0, cx: 0, cy: 0, win: 192, order: [], at: 0, abort: null };
+const S = { index: [], seg: null, view: null, rows: null, plane: 0, cx: 0, cy: 0, win: 192, order: [], at: 0, abort: null,
+  tween: null };   // tween: null, or 0 (published) to 1 (snapped) while the snap animation plays
 
 async function getJSON(url) { const r = await fetch(url, { credentials: 'omit' }); if (!r.ok) throw new Error(`${r.status} ${url}`); return r.json(); }
 
@@ -126,6 +127,7 @@ async function draw() {
   const X = (x) => (x - x0 + 0.5) * k, Y = (y) => (y - y0 + 0.5) * k;
   const css = getComputedStyle(document.documentElement);
   const lw = Math.max(1.5, Math.min(3, k * 0.4));
+  if (S.tween != null) { tweenLine(r, m, X, Y, lw, css); scaleBar(W, k); return; }
   if ($('l-move').checked) {
     // gray strokes from the published line to the snapped one, at each piece's midpoint
     cx2d.strokeStyle = css.getPropertyValue('--move').trim() || 'rgba(200,200,200,.6)';
@@ -144,11 +146,77 @@ async function draw() {
   };
   if ($('l-pub').checked) line(0, css.getPropertyValue('--pub').trim() || '#f08a24');
   if ($('l-snap').checked) line(4, css.getPropertyValue('--snap').trim() || '#2f7bf6');
+  scaleBar(W, k);
+  const keep = {};
+  for (const k of ['data', 'vx', 'tab']) if (params.get(k)) keep[k] = params.get(k);
+  history.replaceState(null, '', `?${new URLSearchParams({ ...keep, seg: S.seg.segment, z: String(z) })}`);
+}
+
+function scaleBar(W, k) {
   // scale bar: 10 voxels
   const um = S.view.voxel_um || null;
   cx2d.fillStyle = '#fff'; cx2d.fillRect(16, W - 22, 10 * k, 4);
   cx2d.font = '13px system-ui, sans-serif'; cx2d.fillText(um ? `10 voxels (${Math.round(10 * um)} µm)` : '10 voxels', 16, W - 30);
-  history.replaceState(null, '', `?${new URLSearchParams({ ...(params.get('data') ? { data: params.get('data') } : {}), seg: S.seg.segment, z: String(z) })}`);
+}
+
+// ---------------------------------------------------------------- snap animation
+
+// Each line piece moves in a straight line from its published position to its snapped one, its color going from the
+// published orange to the snapped blue. Filled and left-in-place vertices are drawn at the published position in both
+// (the legend's rule), so they do not move. One loop: hold 1.2 s on the published line, 2.4 s to the snapped line,
+// hold 1.6 s, 2.4 s back. With prefers-reduced-motion it never plays by itself: each click steps published, halfway,
+// snapped.
+const TW = { hold0: 1200, move: 2400, hold1: 1600 };
+const anim = { on: false, t0: 0, raf: 0, step: -1 };
+const mix = (a, b, t) => { const h = (s) => { const m = s.trim().replace('#', ''); return [0, 2, 4].map((i) => parseInt(m.slice(i, i + 2), 16)); }; const A = h(a), B = h(b); return `rgb(${A.map((v, i) => Math.round(v + (B[i] - v) * t)).join(',')})`; };
+
+function tweenLine(r, m, X, Y, lw, css) {
+  const t = S.tween, pub = css.getPropertyValue('--pub').trim() || '#f08a24', snap = css.getPropertyValue('--snap').trim() || '#2f7bf6';
+  // the published line stays, faint, so the motion reads against it
+  cx2d.globalAlpha = 0.35; cx2d.strokeStyle = pub; cx2d.lineWidth = lw; cx2d.lineCap = 'round'; cx2d.beginPath();
+  for (let i = 0; i < m; i++) { const a = R * i; cx2d.moveTo(X(r[a]), Y(r[a + 1])); cx2d.lineTo(X(r[a + 2]), Y(r[a + 3])); }
+  cx2d.stroke(); cx2d.globalAlpha = 1;
+  cx2d.strokeStyle = mix(pub, snap, t); cx2d.lineWidth = lw; cx2d.beginPath();
+  for (let i = 0; i < m; i++) {
+    const a = R * i, L = (p, q) => p + (q - p) * t;
+    cx2d.moveTo(X(L(r[a], r[a + 4])), Y(L(r[a + 1], r[a + 5]))); cx2d.lineTo(X(L(r[a + 2], r[a + 6])), Y(L(r[a + 3], r[a + 7])));
+  }
+  cx2d.stroke();
+  const W = cv.width, word = t <= 0.001 ? 'Published label' : t >= 0.999 ? 'Snapped label' : 'Snapping along the normal';
+  cx2d.font = '600 15px system-ui, sans-serif'; cx2d.fillStyle = 'rgba(0,0,0,.55)'; cx2d.fillRect(12, 12, cx2d.measureText(word).width + 20, 28);
+  cx2d.fillStyle = '#fff'; cx2d.fillText(word, 22, 31);
+  void W;
+}
+
+function tweenAt(ms) {
+  const cyc = 2 * TW.move + TW.hold0 + TW.hold1, u = ms % cyc;
+  if (u < TW.hold0) return 0;
+  if (u < TW.hold0 + TW.move) return (u - TW.hold0) / TW.move;
+  if (u < TW.hold0 + TW.move + TW.hold1) return 1;
+  return 1 - (u - TW.hold0 - TW.move - TW.hold1) / TW.move;
+}
+
+const reduced = () => window.matchMedia && matchMedia('(prefers-reduced-motion: reduce)').matches;
+
+function animate(on) {
+  if (reduced() && on !== false) {
+    // three still frames, one per click
+    anim.step = (anim.step + 1) % 4;
+    S.tween = anim.step === 3 ? null : [0, 0.5, 1][anim.step];
+    $('b-anim').textContent = anim.step === 3 ? 'Step the snap' : ['Published (1 of 3)', 'Halfway (2 of 3)', 'Snapped (3 of 3)'][anim.step];
+    $('b-anim').setAttribute('aria-pressed', String(S.tween != null));
+    draw();
+    return S.tween != null;
+  }
+  anim.on = on == null ? !anim.on : !!on;
+  cancelAnimationFrame(anim.raf);
+  $('b-anim').setAttribute('aria-pressed', String(anim.on));
+  $('b-anim').textContent = anim.on ? 'Stop' : 'Animate snap';
+  if (!anim.on) { S.tween = null; draw(); return false; }
+  anim.t0 = performance.now();
+  const tick = (now) => { if (!anim.on) return; S.tween = tweenAt(now - anim.t0); draw(); anim.raf = requestAnimationFrame(tick); };
+  anim.raf = requestAnimationFrame(tick);
+  return true;
 }
 
 function msg(t) { const e = $('cv-msg'); e.textContent = t; e.hidden = !t; }
@@ -223,15 +291,18 @@ function listSegs() {
 
 function table() {
   const tb = document.querySelector('#tbl tbody'); tb.innerHTML = '';
+  $('th-claim').hidden = !(window.vxClaim && window.vxClaim('') != null);
   for (const s of S.index) {
     const tr = document.createElement('tr');
-    tr.innerHTML = `<td>${s.scroll}</td><td>${s.segment}</td><td>${s.method}</td><td class="n">${fmt(s.vertices_released)}</td><td class="n">${pct(s.snapped, s.vertices_released)}</td><td class="n">${s.move_voxels && s.move_voxels.median != null ? s.move_voxels.median.toFixed(2) : 'n/a'}</td><td class="n">${fmt(s.vertices_held_back)}</td>`;
+    const claim = window.vxClaim ? window.vxClaim(s.scroll) : null;
+    tr.innerHTML = `<td>${s.scroll}</td><td>${s.segment}</td><td>${s.method}</td><td class="n">${fmt(s.vertices_released)}</td><td class="n">${pct(s.snapped, s.vertices_released)}</td><td class="n">${s.move_voxels && s.move_voxels.median != null ? s.move_voxels.median.toFixed(2) : 'n/a'}</td><td class="n">${fmt(s.vertices_held_back)}</td>${claim ? `<td>${claim}</td>` : ''}`;
     tr.onclick = () => { tab('view'); showStage(); openSeg(s).catch((e) => msg(e.message)); };
     tb.appendChild(tr);
   }
 }
 
 function tab(name) {
+  if (name !== 'view' && anim.on) animate(false);
   document.querySelectorAll('.tabs button').forEach((b) => b.setAttribute('aria-selected', String(b.dataset.tab === name)));
   document.querySelectorAll('[data-pane]').forEach((p) => { p.hidden = p.dataset.pane !== name; });
 }
@@ -244,6 +315,7 @@ $('f-find').oninput = listSegs;
 ['l-pub', 'l-snap', 'l-move'].forEach((id) => { $(id).onchange = () => draw(); });
 $('z-range').oninput = () => { S.plane = Number($('z-range').value); ringOrder(); const r = planeRows(); if (r.length) { let best = Infinity, bi = 0; for (let i = 0; i < r.length / R; i++) { const d = (r[R * i] - S.cx) ** 2 + (r[R * i + 1] - S.cy) ** 2; if (d < best) { best = d; bi = i; } } S.at = Math.max(0, S.order.indexOf(bi)); } draw(); };
 $('win').onchange = () => { S.win = Number($('win').value); draw(); };
+$('b-anim').onclick = () => animate();
 $('b-next').onclick = () => { centerOn(S.at + Math.max(1, Math.round(S.order.length / 24))); draw(); };
 $('b-prev').onclick = () => { centerOn(S.at - Math.max(1, Math.round(S.order.length / 24))); draw(); };
 document.addEventListener('keydown', (e) => {
@@ -263,6 +335,7 @@ window.snappedLabels = {
   segments: () => S.index.slice(),
   open: (segment, z) => { const s = S.index.find((x) => x.segment === segment); if (!s) throw new Error(`no segment ${segment}`); return openSeg(s, z); },
   view: () => (S.view ? { ...S.view, plane: S.view.planes[S.plane], center: [S.cx, S.cy] } : null),
+  animate: (on) => animate(on),
 };
 
 (async function init() {

index.html

@@ -70,6 +70,7 @@
 <!-- space-onescroll:end -->
 </head>
 <body>
+<div class="vx-fixture vx-banner" role="alert" hidden><b>Synthetic fixture.</b> Every number, scroll and line in the Voxel exact tab is made up, to test the page. No real results are shown.</div>
 <header class="top">
   <div class="brand">
     <h1>Snapped Labels</h1>
@@ -78,6 +79,7 @@
   <nav class="tabs" role="tablist">
     <button data-tab="view" role="tab" aria-selected="true">Viewer</button>
     <button data-tab="all" role="tab">All segments</button>
+    <button data-tab="exact" role="tab" id="vx-tabbtn" hidden>Voxel exact</button>
     <button data-tab="how" role="tab">How it works</button>
     <button data-tab="connect" role="tab">Connect your tool</button>
   </nav>
@@ -106,6 +108,7 @@
       <label class="tog"><input type="checkbox" id="l-pub" checked><i class="dot pub"></i>Published</label>
       <label class="tog"><input type="checkbox" id="l-snap" checked><i class="dot snap"></i>Snapped</label>
       <label class="tog"><input type="checkbox" id="l-move" checked><i class="dot move"></i>Moves</label>
+      <button id="b-anim" class="anim" type="button" aria-pressed="false" title="Move each vertex from its published position to its snapped one, slowly, on a loop">Animate snap</button>
     </div>
     <div class="canvaswrap">
       <canvas id="cv" width="720" height="720" aria-label="CT slice with the published and snapped labels"></canvas>
@@ -124,10 +127,122 @@
 
 <section data-pane="all" hidden>
   <div class="tablewrap"><table id="tbl"><thead><tr>
-    <th>Scroll</th><th>Segment</th><th>Method</th><th class="n">Vertices</th><th class="n">Snapped</th><th class="n">Median move</th><th class="n">Held back</th>
+    <th>Scroll</th><th>Segment</th><th>Method</th><th class="n">Vertices</th><th class="n">Snapped</th><th class="n">Median move</th><th class="n">Held back</th><th id="th-claim" hidden>Claim</th>
   </tr></thead><tbody></tbody></table></div>
 </section>
 
+<section data-pane="exact" hidden class="vx">
+  <div class="vx-fixture vx-banner inline" hidden><b>Synthetic fixture.</b> The scrolls SYNTH-A, SYNTH-B and SYNTH-C and every number below are made up, to test the page.</div>
+  <p id="vx-error" class="vx-error" hidden></p>
+  <div class="vx-intro">
+    <h2>Is each snapped vertex within one voxel of the papyrus face?</h2>
+    <p>Per scroll, one of three claim levels. <b>Measured</b>: scored against the face seen in an independent, finer scan of the same scroll, and at least one class cleared the bar. <b>Certified</b>: no finer scan, so a lower bound from a truth-free certificate whose assumptions are listed. <b>Not shown</b>: neither holds, and the card says why; where a test ran, the card still shows what it measured, which makes no claim. Every number here is model output: the snapped meshes come from a band finder, and the truth face is itself found by a rule.</p>
+  </div>
+  <section class="stats vx-tiles" id="vx-tiles" aria-label="Scrolls by claim level"></section>
+  <div id="vx-cards" class="vx-cards"></div>
+
+  <section class="vx-showwrap" aria-labelledby="vx-show-h">
+    <h2 id="vx-show-h">Per-vertex residuals</h2>
+    <p id="vx-show-none" class="hint">No public residual view yet. Drawing the truth face at every vertex would publish where the face is, densely, and spend that region for every later test, so a region appears here only once it is named as spent.</p>
+    <div id="vx-show" hidden>
+      <div class="bar">
+        <select id="vx-show-pick" aria-label="Showcase segment"></select>
+        <span id="vx-show-title" class="vt"></span>
+        <span class="sp"></span>
+        <fieldset class="vx-modes"><legend class="lbl">Color</legend>
+          <label><input type="radio" name="vx-mode" value="signed" checked> signed residual</label>
+          <label><input type="radio" name="vx-mode" value="0.5"> within 0.5</label>
+          <label><input type="radio" name="vx-mode" value="1"> within 1</label>
+          <label><input type="radio" name="vx-mode" value="2"> within 2</label>
+        </fieldset>
+      </div>
+      <div class="vx-showgrid">
+        <div class="vx-heatwrap">
+          <canvas id="vx-heat" width="600" height="150" aria-label="Signed residual at each vertex of the label surface, rows by columns; click a cell to see it on the CT"></canvas>
+          <div id="vx-tip" class="vx-tip" hidden></div>
+          <div id="vx-heat-legend" class="legend vx-heatlegend"></div>
+          <p class="hint">Each cell is a vertex of the label surface (grid rows and columns). Blue: the snapped point lies inward of the truth face; orange: outward. Click a cell to center the CT on it. The outlined row is the z plane shown.</p>
+        </div>
+        <div>
+          <div class="bar">
+            <label class="tog"><input type="checkbox" id="vx-l-pub" checked><i class="dot pub"></i>Published</label>
+            <label class="tog"><input type="checkbox" id="vx-l-snap" checked><i class="dot snap"></i>Snapped</label>
+            <label class="tog"><input type="checkbox" id="vx-l-truth" checked><i class="dot truth"></i>Truth face</label>
+            <span class="sp"></span><span id="vx-z" class="hint"></span>
+            <select id="vx-win" aria-label="Window"><option value="96">96 voxels</option><option value="192" selected>192 voxels</option><option value="384">384 voxels</option></select>
+          </div>
+          <div class="canvaswrap"><canvas id="vx-cv" width="576" height="576" aria-label="CT slice with the published, snapped and truth lines"></canvas></div>
+          <p id="vx-truth-note" class="hint"></p>
+        </div>
+      </div>
+    </div>
+  </section>
+
+  <section class="prose vx-how">
+    <h2>How it is measured</h2>
+    <figure class="fig">
+      <svg class="vx-diagram" viewBox="0 0 680 312" role="img" aria-labelledby="vx-d1t vx-d1d">
+        <title id="vx-d1t">A cross section through two wraps of papyrus</title>
+        <desc id="vx-d1d">The published label sits beside the sheet. The snap moves it along the mesh normal, toward the scroll's center line side, onto the sheet's recto face. The truth face, found in a finer scan, is drawn dashed, with a band of one label voxel on each side. The verso face, on the far side of the sheet, is a control.</desc>
+        <defs><marker id="vx-ah" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0,0L10,5L0,10z" fill="currentColor"/></marker></defs>
+        <path class="d-band" d="M262,20 C250,110 250,190 262,280 L318,280 C306,190 306,110 318,20 Z"/>
+        <path class="d-band" d="M622,20 C610,110 610,190 622,280 L672,280 C660,190 660,110 672,20 Z"/>
+        <rect class="d-tol" x="241" y="20" width="26" height="260" rx="3"/>
+        <path class="d-truth" d="M256,20 C244,110 244,190 256,280"/>
+        <path class="d-recto" d="M262,20 C250,110 250,190 262,280"/>
+        <path class="d-verso" d="M318,20 C306,110 306,190 318,280"/>
+        <line class="d-arrow" x1="72" y1="150" x2="22" y2="150" marker-end="url(#vx-ah)"/>
+        <text x="22" y="132" class="d-t">toward the scroll's</text><text x="22" y="176" class="d-t">center line</text>
+        <line class="d-normal" x1="196" y1="150" x2="245" y2="150" marker-end="url(#vx-ah)"/>
+        <circle class="d-pub" cx="190" cy="150" r="7"/>
+        <circle class="d-snap" cx="253" cy="150" r="7"/>
+        <text x="190" y="128" class="d-t" text-anchor="middle">published</text>
+        <text x="212" y="172" class="d-t muted" text-anchor="middle">normal</text>
+        <line class="d-lead" x1="250" y1="160" x2="200" y2="236"/>
+        <text x="200" y="252" class="d-t" text-anchor="middle">snapped, on the recto face</text>
+        <line class="d-lead" x1="248" y1="62" x2="352" y2="56"/>
+        <text x="358" y="52" class="d-t">truth face (dashed), from the finer scan</text>
+        <text x="358" y="70" class="d-t muted">shaded: ±1 label voxel around it</text>
+        <line class="d-lead" x1="312" y1="208" x2="352" y2="208"/>
+        <text x="358" y="212" class="d-t">verso face: a control</text>
+        <text x="642" y="306" class="d-t muted" text-anchor="middle">next wrap</text>
+        <text x="290" y="306" class="d-t muted" text-anchor="middle">one wrap of papyrus</text>
+        <text x="8" y="306" class="d-t muted">not to scale</text>
+      </svg>
+      <figcaption>One vertex, seen in cross section: published (orange), snapped along its normal onto the recto face (blue), and the truth face (dashed) with its one-voxel band. Not to scale; a label voxel is about 8 to 9 µm.</figcaption>
+    </figure>
+    <ol class="vx-flow" aria-label="How a test runs, in order">
+      <li><b>Release 1.0.1</b>, pinned by its revision, so the vertices scored are the ones you download.</li>
+      <li><b>Split by <code>abstain.tif</code></b>: C0 snapped, C2 filled, C1 left in place. Each is scored on its own.</li>
+      <li><b>Test sites</b> drawn after the rule was frozen, in regions never used before.</li>
+      <li><b>Truth face</b> found in the finer scan (1.129 µm for PHerc0139); a 2.4 µm scan, where one exists, is the positive control.</li>
+      <li><b>Negative controls</b>: the published label, offsets of 1.5 and 3 voxels planted on purpose, and the verso face. Each must fail the bar.</li>
+      <li><b>Verdict</b> per stratum: PASS, FAIL, NOT SHOWN or UNANSWERABLE; or VOID for the whole test when a control or the integrity check breaks.</li>
+    </ol>
+    <h2>The three claim levels</h2>
+    <p><b>Measured.</b> A finer scan of the same scroll exists. At test sites drawn after the rule was fixed, the face is found in it, registered into the label scan, and each snapped vertex's distance to it is measured along the normal. The share within 1 voxel and its one-sided 95% lower bound are reported; the claim holds when the bound clears the bar. The rule was fixed before any test site was looked at; its preregistration digest is <code id="vx-prereg"></code>.</p>
+    <p><b>Certified.</b> No finer scan. A certificate computed from the label scan alone gives a lower bound on the share within 1 voxel, valid only under the assumptions the card lists. It was fixed before any test site was looked at too, under the same preregistration.</p>
+    <p><b>Not shown.</b> Neither a measurement nor a certificate holds for that scroll, or a control failed. The card says why. Where a test ran, the card still shows its shares, intervals and controls, so you can see how far it is from the bar; nothing on it is a claim.</p>
+    <h2>Limits</h2>
+    <ul>
+      <li>A snap moves along the normal only. It cannot fix a label that follows the wrong wrap, and where two sheets touch the face it finds can belong to the neighbor.</li>
+      <li>Only scored strata carry a claim, and a share is a share of test sites, not of every vertex.</li>
+      <li>The truth face is itself found by a rule on the finer scan, so it is model output too.</li>
+      <li>A certificate rests on its stated assumptions. The certificate code and the snapping code are not public.</li>
+      <li>Only the scrolls in the dataset appear here. The meshes are geometry: they say nothing about ink or text.</li>
+    </ul>
+    <h2>What each number is</h2>
+    <div class="vx-tw"><table class="vx-labels"><thead><tr><th>On this tab</th><th>Claim label</th></tr></thead><tbody>
+      <tr><td>Shares, bounds, histograms</td><td>Model output, measured</td></tr>
+      <tr><td>A certificate's bound</td><td>Model output, certified</td></tr>
+      <tr><td>Snapped and truth lines</td><td>Model output</td></tr>
+      <tr><td>Which scrolls are prize-eligible</td><td id="vx-elig">Sourced fact</td></tr>
+    </tbody></table></div>
+    <p class="hint">Source: <span id="vx-src"></span>.</p>
+    <p class="credit">Scans and source meshes: Vesuvius Challenge open data, CC BY-NC 4.0; the snapped meshes are shared under the same terms. Page code Apache 2.0. Made by Chase Hendrick.</p>
+  </section>
+</section>
+
 <section data-pane="how" hidden class="prose">
   <figure class="fig"><img src="https://huggingface.co/datasets/SharpMeow/vesuvius-snapped-labels/resolve/main/snapped-0139.gif" width="600" height="600" alt="PHerc0139 segment w054 on CT at z 8048: the published label, then the snapped label, then both with the moves, at four stops along the label" loading="lazy"><figcaption>PHerc0139 w054, z 8048: published (orange), snapped (blue), both.</figcaption></figure>
   <h2>What a snap does</h2>
@@ -245,5 +360,6 @@ Page source: https://github.com/ChaseHendrick/Scrolls/tree/main/spaces/snapped-l
 </section>
 </main>
 <script src="app.js"></script>
+<script src="vx.js"></script>
 </body>
 </html>

style.css

@@ -79,3 +79,106 @@ tbody tr { cursor: pointer; } tbody tr:hover { background: var(--bg); }
   .side { order: 1; }   /* on a phone the viewer comes first and the list follows it */
   .zl input[type="range"] { width: 160px; }
 }
+
+/* ---------------------------------------------------------------- Voxel exact tab */
+:root { --band: #d9c6a3; --neutral: #c9ccd6; --neg: #2f7bf6; --pos: #d9661a; --heldcell: #ece6ee; --tol: rgba(47, 123, 246, .14);
+  --ok: #1f8a5b; --bad: #c4352b; --warnbg: #fff4d6; --warnink: #6b4a00; --warnline: #e8b931; }
+@media (prefers-color-scheme: dark) {
+  :root { --band: #6d5d43; --neutral: #3d4256; --heldcell: #2a2433; --tol: rgba(110, 160, 255, .18); --ok: #4cc38a; --bad: #ff7a6e;
+    --warnbg: #3a2f10; --warnink: #ffe39a; --warnline: #c99a1c; }
+}
+.vx-banner { background: repeating-linear-gradient(135deg, var(--warnbg) 0 14px, color-mix(in srgb, var(--warnbg) 70%, var(--warnline)) 14px 28px);
+  color: var(--warnink); border-bottom: 2px solid var(--warnline); padding: 8px 24px; font-size: .95em; }
+.vx-banner.inline { border: 2px solid var(--warnline); border-radius: 10px; margin: 0 0 12px; }
+.vx-error { background: var(--panel); border: 2px solid var(--bad); border-radius: 10px; padding: 8px 12px; }
+.vx { max-width: 1100px; }
+.vx-intro h2, .vx-showwrap h2 { font-size: 1.15em; margin: .2em 0 .3em; }
+.vx-intro p { color: var(--mute); max-width: 60em; margin: 0 0 8px; }
+.vx-tiles { padding: 4px 0 12px; grid-template-columns: repeat(3, minmax(0, 1fr)); }
+.vx-t-measured b { color: var(--snap) !important; } .vx-t-certified b { color: var(--accent) !important; } .vx-t-not_shown b { color: var(--mute) !important; }
+.vx-cards { display: grid; gap: 14px; }
+.vx-card { background: var(--panel); border: 1px solid var(--line); border-radius: 12px; padding: 12px 16px; }
+.vx-card.c-measured { border-left: 4px solid var(--snap); } .vx-card.c-certified { border-left: 4px solid var(--accent); }
+.vx-card.c-not_shown { border-left: 4px dashed var(--mute); }
+.vx-head { display: flex; flex-wrap: wrap; justify-content: space-between; align-items: baseline; gap: 6px 16px; }
+.vx-head h3 { margin: 0; font-size: 1.2em; }
+.vx-head small { color: var(--mute); }
+.vx-badge { font-size: .82em; color: var(--mute); border: 1px solid var(--line); border-radius: 99px; padding: 2px 10px; }
+.vx-badge b { color: var(--ink); margin-right: 4px; }
+.vx-headline { font-size: 1.05em; margin: 8px 0 0; }
+.vx-headline b { font-size: 1.35em; }
+.vx-card h4 { font-size: .9em; margin: 12px 0 6px; display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
+.vx-meter { margin-top: 10px; gap: 2px; background: transparent; }
+.vx-meter i:first-child { border-radius: 99px 0 0 99px; } .vx-meter i:last-child { border-radius: 0 99px 99px 0; }
+.vx-chips { display: flex; flex-wrap: wrap; gap: 6px; margin: 10px 0 2px; }
+.vx-chip { font: inherit; font-size: .85em; border: 1px solid var(--line); background: var(--bg); color: var(--ink); border-radius: 8px; padding: 4px 10px; cursor: pointer; }
+.vx-chip.sub { margin-left: 18px; }
+.vx-chip[aria-pressed="true"] { border-color: var(--accent); box-shadow: inset 0 0 0 1px var(--accent); }
+.vx-chip .vx-v { font-weight: 600; margin-left: 4px; }
+.vx-chip.v-pass .vx-v { color: var(--ok); } .vx-chip.v-fail .vx-v { color: var(--bad); }
+.vx-chip.v-not-shown .vx-v, .vx-chip.v-unanswerable .vx-v, .vx-chip.v-void .vx-v { color: var(--mute); }
+.vx-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 6px 22px; }
+.vx-tol { display: grid; gap: 8px; }
+.vx-tolrow { display: grid; grid-template-columns: 70px 1fr 150px; align-items: center; gap: 10px; font-size: .9em; }
+.vx-toll { color: var(--mute); }
+.vx-track { position: relative; height: 14px; border-radius: 4px; background: color-mix(in srgb, var(--line) 70%, transparent); }
+.vx-track.na { background: repeating-linear-gradient(135deg, transparent 0 5px, var(--line) 5px 6px); display: flex; align-items: center; padding-left: 8px; }
+.vx-track.na em { font-size: .8em; color: var(--mute); }
+.vx-fill { position: absolute; left: 0; top: 2px; bottom: 2px; border-radius: 0 4px 4px 0; background: var(--snap); }
+.vx-whisk { position: absolute; top: 50%; height: 0; border-top: 2px solid var(--ink); }
+.vx-whisk::before, .vx-whisk::after { content: ""; position: absolute; top: -6px; height: 10px; border-left: 2px solid var(--ink); }
+.vx-whisk::before { left: 0; } .vx-whisk::after { right: 0; }
+.vx-barline { position: absolute; top: -4px; bottom: -4px; border-left: 2px dashed var(--ink); }
+.vx-tolv b { font-variant-numeric: tabular-nums; } .vx-tolv small { color: var(--mute); display: block; font-size: .78em; }
+.vx-hist { width: 100%; height: auto; display: block; color: var(--ink); }
+.vx-hist .vx-band { fill: var(--tol); }
+.vx-hist .vx-hbar { fill: var(--snap); }
+.vx-hist .vx-hpub { fill: none; stroke: var(--pub); stroke-width: 2; stroke-linejoin: round; }
+.vx-hist .vx-base { stroke: var(--line); stroke-width: 1; }
+.vx-hist .vx-zero { stroke: var(--mute); stroke-width: 1; }
+.vx-hist .vx-tick { stroke: var(--mute); } .vx-hist .vx-tickt { fill: var(--mute); font-size: 10px; }
+.vx-pubtog { font-weight: 400; font-size: .95em; }
+.vx-ctl { list-style: none; padding: 0; margin: 0; display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 2px 18px; font-size: .86em; }
+.vx-ctl li.yes span { color: var(--ok); font-weight: 700; } .vx-ctl li.no span { color: var(--bad); font-weight: 700; }
+.vx-not { margin-top: 10px; }
+.vx-assume { margin: 4px 0 8px; font-size: .9em; }
+.vx-num summary { cursor: pointer; color: var(--accent); margin-top: 6px; }
+.vx-num table { font-size: .82em; }
+.vx-showwrap { background: var(--panel); border: 1px solid var(--line); border-radius: 12px; padding: 12px 16px; margin: 16px 0; }
+.vx-showgrid { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 576px); gap: 16px; align-items: start; }
+.vx-heatwrap { position: relative; min-width: 0; }
+#vx-heat { width: 100%; height: auto; image-rendering: pixelated; border-radius: 8px; border: 1px solid var(--line); cursor: pointer; }
+.vx-tip { position: absolute; background: var(--ink); color: var(--bg); font-size: .8em; padding: 3px 8px; border-radius: 6px; pointer-events: none; white-space: nowrap; }
+.vx-heatlegend { margin-top: 6px; align-items: center; }
+.vx-grad { display: inline-block; width: 120px; height: 10px; border-radius: 3px; background: linear-gradient(90deg, var(--neg), var(--neutral), var(--pos)); }
+.legend i.hatch { background: repeating-linear-gradient(135deg, transparent 0 2px, var(--mute) 2px 3px); border: 1px solid var(--line); }
+.vx-modes { border: 0; margin: 0; padding: 0; display: inline-flex; gap: 10px; align-items: center; flex-wrap: wrap; font-size: .88em; color: var(--mute); }
+.vx-modes legend { float: left; margin-right: 6px; }
+.dot.truth { background: transparent; border: 2px dashed var(--ink); width: 12px; height: 12px; }
+#vx-cv { cursor: default; }
+.vx-how { max-width: none; margin-top: 16px; }
+.vx-diagram { width: 100%; max-width: 680px; height: auto; display: block; color: var(--ink); font: 13px system-ui, sans-serif; }
+.vx-diagram .d-band { fill: var(--band); }
+.vx-diagram .d-tol { fill: var(--tol); }
+.vx-diagram .d-truth { fill: none; stroke: var(--ink); stroke-width: 2; stroke-dasharray: 6 5; }
+.vx-diagram .d-recto { fill: none; stroke: var(--snap); stroke-width: 2.5; }
+.vx-diagram .d-verso { fill: none; stroke: var(--mute); stroke-width: 2; stroke-dasharray: 2 4; }
+.vx-diagram .d-arrow, .vx-diagram .d-normal { stroke: currentColor; stroke-width: 2; }
+.vx-diagram .d-lead { stroke: var(--mute); stroke-width: 1; }
+.vx-diagram .d-pub { fill: var(--pub); stroke: var(--panel); stroke-width: 2; }
+.vx-diagram .d-snap { fill: var(--snap); stroke: var(--panel); stroke-width: 2; }
+.vx-diagram .d-t { fill: currentColor; } .vx-diagram .muted { fill: var(--mute); }
+.vx-flow { list-style: none; counter-reset: f; padding: 0; display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 8px; }
+.vx-flow li { counter-increment: f; position: relative; background: var(--bg); border: 1px solid var(--line); border-radius: 10px; padding: 26px 10px 10px; font-size: .86em; }
+.vx-flow li::before { content: counter(f); position: absolute; top: 6px; left: 10px; font-weight: 700; color: var(--accent); }
+.vx-tw { background: var(--panel); border: 1px solid var(--line); border-radius: 12px; }
+.vx-tw th, .vx-tw td { white-space: normal; overflow-wrap: anywhere; padding: 5px 8px; }
+#vx-prereg { overflow-wrap: anywhere; word-break: break-all; }
+button.anim { font: inherit; font-size: .9em; border: 1px solid var(--line); background: var(--panel); color: var(--ink); border-radius: 99px; padding: 3px 12px; cursor: pointer; }
+button.anim[aria-pressed="true"] { border-color: var(--snap); box-shadow: inset 0 0 0 1px var(--snap); }
+@media (max-width: 760px) {
+  .vx-banner { padding-left: 16px; padding-right: 16px; }
+  .vx-grid, .vx-showgrid { grid-template-columns: 1fr; }
+  .vx-tolrow { grid-template-columns: 60px 1fr 110px; }
+  .vx-ctl { grid-template-columns: 1fr; }
+}

vx.js

@@ -0,0 +1,382 @@
+// Snapped Labels, "Voxel exact" tab: per-scroll claim levels (Measured, Certified, Not shown), tolerance bars, abstain
+// strata, residual histograms and controls, read from vx/summary.json (schema snapped-labels/voxel-exact@1, checked by
+// python -m kit vxsummary check). ?vx=URL reads another summary; ?vx=fixture reads the synthetic fixture, always under a
+// banner. The tab stays hidden until a summary loads and validates. Loaded after app.js and uses its helpers.
+'use strict';
+
+const VX = { doc: null, url: null, fixture: false, show: null, showIdx: 0, mode: 'signed', pick: {} };
+const VX_SCHEMA = 'snapped-labels/voxel-exact@1';
+const VX_CLAIMS = { measured: 'Measured', certified: 'Certified', not_shown: 'Not shown' };
+const VX_ORDER = { measured: 0, certified: 1, not_shown: 2 };
+const VX_TOLS = ['0.5', '1', '2'];
+// a verdict is text plus a shape, never color alone
+const VX_ICON = { PASS: '✓', FAIL: '✕', 'NOT SHOWN': '○', UNANSWERABLE: '?', VOID: '⊘' };
+const VX_STRATUM_NAME = { C0: 'snapped (code 0)', C0L: 'snapped, placed in the label scan (code 0)', C2: 'filled (code 2)', C1: 'left in place (code 1)' };
+
+const esc = (s) => String(s == null ? '' : s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
+const p1 = (x) => (x == null || !Number.isFinite(x) ? 'n/a' : `${(100 * x).toFixed(1)}%`);
+const sgn = (x) => (x > 0 ? `+${x.toFixed(2)}` : x.toFixed(2));
+
+function vxURL() {
+  const q = params.get('vx');
+  if (q === 'fixture') return new URL('vx/fixture/summary.json', location.href).href;
+  return new URL(q || 'vx/summary.json', location.href).href;
+}
+
+// The page's own check, a subset of kit/vxsummary.py: enough that a broken file never draws as numbers.
+function vxValid(d) {
+  const bad = [];
+  if (!d || d.schema !== VX_SCHEMA) bad.push(`schema is not ${VX_SCHEMA}`);
+  if (!d || !Array.isArray(d.scrolls) || !d.scrolls.length) bad.push('no scrolls');
+  for (const s of (d && d.scrolls) || []) {
+    if (!(s.claim in VX_CLAIMS)) bad.push(`${s.scroll}: claim ${s.claim}`);
+    for (const st of s.strata || []) for (const t of VX_TOLS) {
+      const w = st.within && st.within[t];
+      if (w && !(w.n >= w.k && w.k >= 0 && w.share >= 0 && w.share <= 1)) bad.push(`${s.scroll} ${st.id} within ${t}`);
+    }
+  }
+  if (d && typeof d.fixture !== 'boolean') bad.push('fixture flag missing');
+  return bad;
+}
+
+// ---------------------------------------------------------------- small charts
+
+function tolBars(st, rule) {
+  const bar = rule && rule.bar != null ? rule.bar : 0.9;
+  return `<div class="vx-tol" role="list">${VX_TOLS.map((t) => {
+    const w = st.within[t];
+    const label = `${t === '1' ? '1 voxel' : `${t} voxels`}`;
+    if (!w) return `<div class="vx-tolrow" role="listitem"><span class="vx-toll">${label}</span><span class="vx-track na"><em>not measured</em></span><span class="vx-tolv">n/a</span></div>`;
+    const lo = w.lower != null ? w.lower : null, hi = w.upper != null ? w.upper : null;
+    const whisk = lo != null ? `<i class="vx-whisk" style="left:${100 * lo}%;width:${100 * ((hi != null ? hi : w.share) - lo)}%"></i>` : '';
+    const line = t === '1' ? `<i class="vx-barline" style="left:${100 * bar}%" title="the bar, ${p1(bar)}"></i>` : '';
+    return `<div class="vx-tolrow" role="listitem"><span class="vx-toll">${label}</span>
+      <span class="vx-track" title="${w.k} of ${w.n} sites (${w.basis === 'itt' ? 'every selected site' : 'scorable sites'})${lo != null ? `; one-sided 95% interval ${p1(lo)} to ${p1(hi)}` : ''}">
+        <i class="vx-fill" style="width:${100 * w.share}%"></i>${whisk}${line}</span>
+      <span class="vx-tolv"><b>${p1(w.share)}</b> <small>${w.k} of ${w.n}${w.basis === 'itt' ? ', every selected site' : ', scorable sites'}</small></span></div>`;
+  }).join('')}</div>`;
+}
+
+function hist(st, showPub) {
+  const h = st.residual_hist, ph = st.published_hist;
+  if (!h || !h.edges || h.edges.length < 2) return '<p class="hint">No residual distribution for this stratum.</p>';
+  const W = 360, H = 130, L = 8, B = 22, T = 10;
+  const e = h.edges, lo = e[0], hi = e[e.length - 1];
+  const X = (v) => L + (W - 2 * L) * (v - lo) / (hi - lo);
+  const all = [...h.counts, ...(showPub && ph && ph.counts ? ph.counts : [])];
+  const max = Math.max(1, ...all);
+  const Y = (c) => H - B - (H - B - T) * c / max;
+  let bars = '';
+  h.counts.forEach((c, i) => {
+    if (!c) return;
+    const x0 = X(e[i]) + 1, x1 = X(e[i + 1]) - 1;
+    bars += `<rect class="vx-hbar" x="${x0.toFixed(1)}" y="${Y(c).toFixed(1)}" width="${Math.max(1, x1 - x0).toFixed(1)}" height="${(H - B - Y(c)).toFixed(1)}" rx="1.5"><title>${e[i]} to ${e[i + 1]} voxels: ${c} sites</title></rect>`;
+  });
+  let pub = '';
+  if (showPub && ph && ph.counts && ph.edges && ph.edges.length === ph.counts.length + 1) {
+    let d = `M${X(ph.edges[0]).toFixed(1)},${Y(0).toFixed(1)}`;
+    ph.counts.forEach((c, i) => { d += `L${X(ph.edges[i]).toFixed(1)},${Y(c).toFixed(1)}L${X(ph.edges[i + 1]).toFixed(1)},${Y(c).toFixed(1)}`; });
+    d += `L${X(ph.edges[ph.edges.length - 1]).toFixed(1)},${Y(0).toFixed(1)}`;
+    pub = `<path class="vx-hpub" d="${d}"><title>published label</title></path>`;
+  }
+  const ticks = [-4, -2, -1, 0, 1, 2, 4].filter((v) => v >= lo && v <= hi)
+    .map((v) => `<line class="vx-tick" x1="${X(v)}" x2="${X(v)}" y1="${H - B}" y2="${H - B + 4}"/><text class="vx-tickt" x="${X(v)}" y="${H - 6}" text-anchor="middle">${v > 0 ? '+' + v : v}</text>`).join('');
+  const out = (h.under || h.over) ? `<text class="vx-tickt" x="${W - L}" y="${T + 2}" text-anchor="end">${h.under} below ${lo}, ${h.over} above +${hi}</text>` : '';
+  return `<svg class="vx-hist" viewBox="0 0 ${W} ${H}" role="img" aria-label="Signed residual of the snapped vertices, in label voxels, ${h.counts.reduce((a, b) => a + b, 0)} sites${showPub ? ', with the published label' : ''}">
+    <rect class="vx-band" x="${X(-1)}" y="${T}" width="${X(1) - X(-1)}" height="${H - B - T}"><title>within 1 voxel</title></rect>
+    <line class="vx-base" x1="${L}" x2="${W - L}" y1="${H - B}" y2="${H - B}"/>
+    ${bars}${pub}
+    <line class="vx-zero" x1="${X(0)}" x2="${X(0)}" y1="${T}" y2="${H - B}"/>
+    ${ticks}${out}</svg>`;
+}
+
+function meter(s) {
+  const v = s.vertices, by = v.by_code, tot = Math.max(1, v.released + v.held_back);
+  const part = (n, color) => (n ? `<i style="width:calc(${100 * n / tot}% - 2px);background:${color}"></i>` : '');
+  return `<div class="meter vx-meter">${part(by['0'], 'var(--snap)')}${part(by['2'], 'var(--fill)')}${part(by['1'], 'var(--pub)')}${part(v.held_back, 'var(--held)')}</div>
+    <div class="legend"><span><i style="background:var(--snap)"></i>snapped ${p1(by['0'] / tot)}</span><span><i style="background:var(--fill)"></i>filled ${p1(by['2'] / tot)}</span><span><i style="background:var(--pub)"></i>left in place ${p1(by['1'] / tot)}</span><span><i style="background:var(--held)"></i>held back ${p1(v.held_back / tot)}</span></div>`;
+}
+
+function chip(st, on, scroll) {
+  const icon = VX_ICON[st.verdict] || '';
+  return `<button class="vx-chip v-${st.verdict.replace(' ', '-').toLowerCase()}${st.id === 'C0L' ? ' sub' : ''}" data-scroll="${esc(scroll)}" data-stratum="${esc(st.id)}" aria-pressed="${on}" title="${esc(st.why)}">
+    <b>${esc(st.id)}</b> ${esc(VX_STRATUM_NAME[st.id] || '')} <span class="vx-v"><span aria-hidden="true">${icon}</span> ${esc(st.verdict)}</span></button>`;
+}
+
+function controls(st) {
+  if (!st.controls || !st.controls.length) return '';
+  return `<ul class="vx-ctl">${st.controls.map((c) => {
+    const state = c.holds == null ? 'not measured' : c.holds ? 'holds' : 'does not hold';
+    return `<li class="${c.holds === false ? 'no' : c.holds ? 'yes' : ''}"><span aria-hidden="true">${c.holds == null ? '·' : c.holds ? '✓' : '✕'}</span> ${esc(c.name)}: ${p1(c.observed)} within 1 voxel, required ${esc(c.require)} ${p1(c.limit)}: <b>${state}</b></li>`;
+  }).join('')}</ul>`;
+}
+
+function numbers(s) {
+  const rows = [];
+  for (const st of s.strata || []) {
+    for (const t of VX_TOLS) {
+      const w = st.within[t];
+      rows.push(`<tr><td>${esc(st.id)}</td><td>${esc(st.verdict)}</td><td>${t}</td><td class="n">${w ? w.k : ''}</td><td class="n">${w ? w.n : ''}</td><td class="n">${w ? p1(w.share) : 'not measured'}</td><td class="n">${w && w.lower != null ? p1(w.lower) : ''}</td><td class="n">${w && w.upper != null ? p1(w.upper) : ''}</td><td>${w ? esc(w.basis) : ''}</td></tr>`);
+    }
+  }
+  const v = s.vertices;
+  return `<details class="vx-num"><summary>Show numbers</summary>
+    <p class="hint">Vertices released ${fmt(v.released)} (code 0: ${fmt(v.by_code['0'])}, code 2: ${fmt(v.by_code['2'])}, code 1: ${fmt(v.by_code['1'])}), held back ${fmt(v.held_back)}. Label scan ${esc(s.label_scan.voxel_um)} µm${s.truth ? `; truth ${esc(s.truth.voxel_um)} µm scan` : ''}${s.oracle ? `; positive control ${esc(s.oracle.voxel_um)} µm scan` : ''}.${s.void && s.void.length ? ` Void: ${esc(s.void.join('; '))}.` : ''}</p>
+    ${rows.length ? `<div class="vx-tw"><table><thead><tr><th>Stratum</th><th>Verdict</th><th>Voxels</th><th class="n">k</th><th class="n">n</th><th class="n">Share</th><th class="n">Lower</th><th class="n">Upper</th><th>Basis</th></tr></thead><tbody>${rows.join('')}</tbody></table></div>` : ''}
+    ${s.certificate ? `<p class="hint">Certificate: ${esc(s.certificate.method)}, lower bound ${p1(s.certificate.lower)} at ${p1(s.certificate.level)} over ${fmt(s.certificate.n)} vertices.</p>` : ''}</details>`;
+}
+
+// ---------------------------------------------------------------- cards
+
+function stratumOrder(strata) {
+  const rank = { C0: 0, C0L: 1, C2: 2, C1: 3 };
+  return strata.slice().sort((a, b) => (rank[a.id] ?? 9) - (rank[b.id] ?? 9));
+}
+
+function strataBody(s, rule) {
+  const strata = stratumOrder(s.strata || []);
+  const prim = strata.find((x) => x.primary) || strata[0];
+  const cur = strata.find((x) => x.id === VX.pick[s.scroll]) || prim;
+  const one = prim && prim.within['1'];
+  const pubc = prim && (prim.controls || []).find((c) => /^published/.test(c.name));
+  const head2 = one ? `<p class="vx-headline"><b>${p1(one.share)}</b> within 1 voxel (${esc(prim.id)}, <span aria-hidden="true">${VX_ICON[prim.verdict] || ''}</span> ${esc(prim.verdict)}). One-sided 95% lower bound ${p1(one.lower)} (bar ${p1(rule.bar)}).</p>
+    <p class="hint">${pubc ? `${esc(pubc.name.replace(/^published label/, 'Published label'))}: ${p1(pubc.observed)}.` : ''}${s.void && s.void.length ? ` The test is void: ${esc(s.void.join('; '))}.` : ''}</p>` : '';
+  const pubOn = !!VX.pick[`${s.scroll}:pub`];
+  return `${head2}
+    ${meter(s)}
+    <div class="vx-chips" role="group" aria-label="Strata">${strata.map((x) => chip(x, x.id === cur.id, s.scroll)).join('')}</div>
+    <div class="vx-grid">
+      <div><h4>${esc(cur.id)}: share within each tolerance</h4>${tolBars(cur, rule)}
+        <p class="hint">${esc(cur.verdict)}: ${esc(cur.why)}${cur.instrument_limited ? ' (limited by the instrument)' : ''}. ${cur.n_selected} sites selected, ${cur.n_scorable} scorable. Whiskers: one-sided 95% interval. Dashed line: the bar.</p></div>
+      <div><h4>${esc(cur.id)}: signed residual, voxels <label class="tog vx-pubtog"><input type="checkbox" data-pub="${esc(s.scroll)}"${pubOn ? ' checked' : ''}><i class="dot pub"></i>published label</label></h4>
+        ${hist(cur, pubOn)}
+        <p class="hint">${esc(cur.residual_hist && cur.residual_hist.sign ? cur.residual_hist.sign : '')}. Shaded: within 1 voxel.${cur.median_abs != null ? ` Median distance ${cur.median_abs.toFixed(2)} voxels.` : ''}</p></div>
+    </div>
+    <h4>Controls (each must be able to fail)</h4>${controls(cur)}
+    <p class="hint vx-not">What this does not show: labels that follow the wrong wrap, sheets that touch with no gap, and any scroll, segment or region not scored here.</p>
+    ${numbers(s)}`;
+}
+
+function scrollCard(s) {
+  const rule = VX.doc.rule || {};
+  const badge = { measured: 'Model output, measured against an independent finer scan', certified: 'Model output, truth-free certificate', not_shown: (s.strata || []).length ? 'tested; no claim' : 'no claim' }[s.claim];
+  const head = `<header class="vx-head"><div><h3>${esc(s.scroll)}</h3><small>label scan ${esc(s.label_scan.voxel_um)} µm voxels${s.truth ? `, truth from a ${esc(s.truth.voxel_um)} µm scan` : ''}</small></div>
+    <span class="vx-badge c-${s.claim}"><b>${VX_CLAIMS[s.claim]}</b> ${badge}</span></header>`;
+  if (s.claim === 'not_shown') {
+    const tested = (s.strata || []).length > 0;
+    return `<article class="vx-card c-${s.claim}" data-scroll="${esc(s.scroll)}">${head}<p>Not shown: ${esc(s.why_not_shown)}.${tested ? ' The numbers below are what the test measured (model output); they make no claim.' : ''}</p>${tested ? strataBody(s, rule) : `${meter(s)}${numbers(s)}`}</article>`;
+  }
+  if (s.claim === 'certified') {
+    const c = s.certificate;
+    return `<article class="vx-card c-${s.claim}" data-scroll="${esc(s.scroll)}">${head}
+      <p class="vx-headline">One-sided ${p1(c.level)} lower bound <b>${p1(c.lower)}</b> within 1 voxel (bar ${p1(rule.bar)}).</p>
+      <p class="hint">No truth scan; lower bound from the certificate, over ${fmt(c.n)} vertices. It rests on these assumptions:</p>
+      <ul class="vx-assume">${c.assumptions.map((a) => `<li>${esc(a)}</li>`).join('')}</ul>
+      ${meter(s)}${numbers(s)}</article>`;
+  }
+  return `<article class="vx-card c-${s.claim}" data-scroll="${esc(s.scroll)}">${head}${strataBody(s, rule)}</article>`;
+}
+
+function renderCards() {
+  const d = VX.doc;
+  const sc = d.scrolls.slice().sort((a, b) => VX_ORDER[a.claim] - VX_ORDER[b.claim]);
+  const count = (c) => d.scrolls.filter((s) => s.claim === c).length;
+  $('vx-tiles').innerHTML = ['measured', 'certified', 'not_shown'].map((c) => `<div class="stat vx-t-${c}"><b>${count(c)}</b><span>scrolls ${VX_CLAIMS[c].toLowerCase()}</span></div>`).join('');
+  $('vx-cards').innerHTML = sc.map(scrollCard).join('');
+  $('vx-cards').querySelectorAll('.vx-chip').forEach((b) => { b.onclick = () => { VX.pick[b.dataset.scroll] = b.dataset.stratum; renderCards(); }; });
+  $('vx-cards').querySelectorAll('input[data-pub]').forEach((c) => { c.onchange = () => { VX.pick[`${c.dataset.pub}:pub`] = c.checked; renderCards(); }; });
+  const pre = d.prereg || {};
+  $('vx-prereg').textContent = `${pre.sha256 || 'n/a'}, frozen ${pre.frozen || 'n/a'}`;
+  const pr = d.prizes_read || {};
+  $('vx-elig').innerHTML = d.fixture ? 'The fixture\'s scrolls are made up.' : `Sourced fact: none of these scrolls is on the prize lists at <a href="${esc(/^https:\/\//.test(String(pr.url)) ? pr.url : 'https://scrollprize.org/prizes')}" target="_blank" rel="noopener">scrollprize.org/prizes</a> (read ${esc(pr.date)}).`;
+  $('vx-src').textContent = `${d.dataset.repo} ${d.dataset.release} at ${d.dataset.revision.slice(0, 12)}, summary ${d.generated}${d.fixture ? ', synthetic fixture' : ''}`;
+}
+
+// ---------------------------------------------------------------- showcase: residual heatmap and CT with the truth face
+
+const RS = 12;   // floats per showcase line piece: published, snapped, truth (ax ay bx by each)
+
+async function openShowcase(segment) {
+  const list = (VX.doc && VX.doc.showcase) || [];
+  const e = list.find((x) => x.segment === segment) || list[0];
+  if (!e) throw new Error('no showcase segment');
+  const base = new URL(e.file, VX.url).href;
+  const meta = await getJSON(base);
+  // the grids are plain number lists (null: no value)
+  const res = Float32Array.from(meta.residual, (v) => (v == null ? NaN : v)), state = Uint8Array.from(meta.state);
+  const xyz = Float32Array.from(meta.xyz), rows = Float32Array.from(meta.rows);
+  VX.show = { meta, res, state, xyz, rows, plane: 0, cx: 0, cy: 0, win: Number($('vx-win').value) || 192, ct: null,
+    mode: (document.querySelector('input[name="vx-mode"]:checked') || {}).value || 'signed' };
+  $('vx-show-title').textContent = `${meta.scroll} · ${meta.segment}`;
+  $('vx-truth-note').textContent = meta.truth_note;
+  const mid = Math.floor(meta.planes.length / 2);
+  pickPlane(mid);
+  heat();
+  await showDraw();
+}
+
+function pickPlane(i) {
+  // center on a piece a quarter of the way along the plane's line
+  const V = VX.show, p = V.meta.planes[i];
+  V.plane = i;
+  if (!p || !p.count) return;
+  const q = RS * (p.first + Math.floor(p.count / 4));
+  V.cx = V.rows[q + 4]; V.cy = V.rows[q + 5];
+}
+
+function divColor(v, css) {
+  // diverging: blue (negative) to a neutral gray to orange (positive), clamped at +-2 voxels
+  const t = Math.max(-1, Math.min(1, v / 2));
+  const hex = (s) => { const m = s.trim().replace('#', ''); return [0, 2, 4].map((i) => parseInt(m.slice(i, i + 2), 16)); };
+  const neg = hex(css.getPropertyValue('--neg') || '#2f7bf6'), pos = hex(css.getPropertyValue('--pos') || '#e0701a'), mid = hex(css.getPropertyValue('--neutral') || '#c9ccd6');
+  const a = t < 0 ? neg : pos, k = Math.abs(t);
+  return `rgb(${mid.map((m, i) => Math.round(m + (a[i] - m) * k)).join(',')})`;
+}
+
+function heat() {
+  const V = VX.show; if (!V) return;
+  const [h, w] = V.meta.shape, cv2 = $('vx-heat'), g = cv2.getContext('2d');
+  const cw = Math.max(2, Math.floor(Math.min(900, cv2.parentNode.clientWidth || 600) / w));
+  cv2.width = w * cw; cv2.height = h * cw;
+  const css = getComputedStyle(document.documentElement);
+  const surf = css.getPropertyValue('--panel').trim() || '#fff', line = css.getPropertyValue('--line').trim() || '#ccc';
+  const tol = V.mode === 'signed' ? null : Number(V.mode);
+  g.fillStyle = surf; g.fillRect(0, 0, cv2.width, cv2.height);
+  for (let i = 0; i < h; i++) for (let j = 0; j < w; j++) {
+    const k = i * w + j, s = V.state[k], x = j * cw, y = i * cw;
+    if (s === 2) { g.fillStyle = css.getPropertyValue('--heldcell').trim() || '#ddd'; g.fillRect(x, y, cw, cw); continue; }   // held back: never drawn
+    if (s === 1 || !Number.isFinite(V.res[k])) {                       // no value: hatched
+      g.strokeStyle = line; g.lineWidth = 1; g.beginPath(); g.moveTo(x, y + cw); g.lineTo(x + cw, y); g.stroke(); continue;
+    }
+    const v = V.res[k];
+    g.fillStyle = tol == null ? divColor(v, css) : (Math.abs(v) <= tol ? css.getPropertyValue('--snap').trim() : css.getPropertyValue('--pub').trim());
+    g.fillRect(x, y, cw, cw);
+  }
+  const p = V.meta.planes[V.plane];
+  if (p) { const i = V.meta.planes.indexOf(p); g.strokeStyle = css.getPropertyValue('--ink').trim(); g.lineWidth = 2; g.strokeRect(1, i * cw + 1, cv2.width - 2, cw - 2); }
+  V.cw = cw;
+  $('vx-heat-legend').innerHTML = tol == null
+    ? `<span class="vx-grad" aria-hidden="true"></span><span>-2</span><span>0</span><span>+2 voxels (clamped)</span><span><i class="hatch"></i>no value</span><span><i style="background:var(--heldcell)"></i>held back for evaluation</span>`
+    : `<span><i style="background:var(--snap)"></i>within ${tol} voxel${tol === 1 ? '' : 's'}</span><span><i style="background:var(--pub)"></i>not within</span><span><i class="hatch"></i>no value</span><span><i style="background:var(--heldcell)"></i>held back for evaluation</span>`;
+}
+
+async function showDraw() {
+  const V = VX.show; if (!V) return;
+  const cvs = $('vx-cv'), g = cvs.getContext('2d'), W = cvs.width, n = V.win, k = W / n;
+  const p = V.meta.planes[V.plane], z = p ? p.z : 0;
+  const x0 = Math.round(V.cx - n / 2), y0 = Math.round(V.cy - n / 2);
+  $('vx-z').textContent = `z ${z}`;
+  if (V.meta.volume) {
+    const key = `${z}|${y0}|${x0}|${n}`;
+    if (!V.ct || V.ct.key !== key) {
+      const buf = await ctWindow(V.meta.volume, z, y0, x0, n);
+      const img = new ImageData(n, n);
+      for (let i = 0; i < n * n; i++) { img.data[4 * i] = img.data[4 * i + 1] = img.data[4 * i + 2] = buf[i]; img.data[4 * i + 3] = 255; }
+      const off = document.createElement('canvas'); off.width = off.height = n; off.getContext('2d').putImageData(img, 0, 0);
+      V.ct = { key, img: off };
+    }
+    g.imageSmoothingEnabled = false; g.drawImage(V.ct.img, 0, 0, W, W);
+  } else {
+    g.fillStyle = '#15171f'; g.fillRect(0, 0, W, W);
+    g.fillStyle = 'rgba(255,255,255,.55)'; g.font = '14px system-ui, sans-serif'; g.fillText('Synthetic fixture: no CT', 14, 24);
+  }
+  const X = (x) => (x - x0 + 0.5) * k, Y = (y) => (y - y0 + 0.5) * k;
+  const css = getComputedStyle(document.documentElement);
+  const piece = (o, color, width, dash) => {
+    g.strokeStyle = color; g.lineWidth = width; g.setLineDash(dash || []); g.lineCap = 'round'; g.beginPath();
+    for (let q = p.first; q < p.first + p.count; q++) { const a = RS * q + o; g.moveTo(X(V.rows[a]), Y(V.rows[a + 1])); g.lineTo(X(V.rows[a + 2]), Y(V.rows[a + 3])); }
+    g.stroke(); g.setLineDash([]);
+  };
+  if (p && p.count && !V.meta.volume) {
+    // no CT in the fixture: a made-up sheet, drawn as a band along the made-up face
+    piece(8, css.getPropertyValue('--band').trim() || '#d9c6a3', 7 * k);
+  }
+  if (p && p.count) {
+    if ($('vx-l-pub').checked) piece(0, css.getPropertyValue('--pub').trim(), 2.5);
+    if ($('vx-l-snap').checked) piece(4, css.getPropertyValue('--snap').trim(), 2.5);
+    if ($('vx-l-truth').checked) { piece(8, '#11131c', 4.5, [7, 5]); piece(8, '#ffffff', 2, [7, 5]); }
+  }
+  g.fillStyle = '#fff'; g.fillRect(16, W - 22, 10 * k, 4);
+  g.font = '13px system-ui, sans-serif'; g.fillText(V.meta.voxel_um ? `10 voxels (${Math.round(10 * V.meta.voxel_um)} µm)` : '10 voxels', 16, W - 30);
+}
+
+function heatCell(ev) {
+  const V = VX.show; if (!V) return null;
+  const b = $('vx-heat').getBoundingClientRect(), [h, w] = V.meta.shape;
+  const j = Math.floor((ev.clientX - b.left) / b.width * w), i = Math.floor((ev.clientY - b.top) / b.height * h);
+  if (i < 0 || j < 0 || i >= h || j >= w) return null;
+  return { i, j, k: i * w + j };
+}
+
+// ---------------------------------------------------------------- wiring
+
+function wireShowcase() {
+  const heatCv = $('vx-heat'), tip = $('vx-tip');
+  heatCv.addEventListener('mousemove', (ev) => {
+    const c = heatCell(ev), V = VX.show; if (!c) { tip.hidden = true; return; }
+    const s = V.state[c.k], v = V.res[c.k];
+    tip.textContent = s === 2 ? 'held back for evaluation' : (s === 1 || !Number.isFinite(v)) ? 'no value here' : `${sgn(v)} voxels (row ${c.i}, column ${c.j})`;
+    tip.hidden = false; tip.style.left = `${ev.offsetX + 14}px`; tip.style.top = `${ev.offsetY + 10}px`;
+  });
+  heatCv.addEventListener('mouseleave', () => { tip.hidden = true; });
+  heatCv.addEventListener('click', (ev) => {
+    const c = heatCell(ev), V = VX.show; if (!c || V.state[c.k] === 2) return;
+    const x = V.xyz[3 * c.k], y = V.xyz[3 * c.k + 1], z = V.xyz[3 * c.k + 2];
+    let best = Infinity, bi = 0;
+    V.meta.planes.forEach((p, i) => { const d = Math.abs(p.z - z); if (d < best) { best = d; bi = i; } });
+    V.plane = bi; V.cx = x; V.cy = y; heat(); showDraw();
+  });
+  document.querySelectorAll('input[name="vx-mode"]').forEach((r) => { r.onchange = () => { VX.show.mode = r.value; heat(); }; });
+  ['vx-l-pub', 'vx-l-snap', 'vx-l-truth'].forEach((id) => { $(id).onchange = () => showDraw(); });
+  $('vx-win').onchange = () => { VX.show.win = Number($('vx-win').value); showDraw(); };
+  window.addEventListener('resize', () => heat());
+}
+
+async function vxInit() {
+  VX.url = vxURL();
+  let d;
+  try {
+    const r = await fetch(VX.url, { credentials: 'omit' });
+    if (!r.ok) { if (params.get('vx')) throw new Error(`${r.status} ${VX.url}`); return; }   // no results yet: the tab stays hidden
+    d = await r.json();
+  } catch (e) {
+    if (!params.get('vx')) return;
+    $('vx-tabbtn').hidden = false; $('vx-error').hidden = false; $('vx-error').textContent = `Could not load the voxel-exact summary: ${e.message}`; return;
+  }
+  const bad = vxValid(d);
+  if (bad.length) {
+    if (!params.get('vx')) return;
+    $('vx-tabbtn').hidden = false; $('vx-error').hidden = false; $('vx-error').textContent = `The voxel-exact summary does not validate: ${bad.slice(0, 3).join('; ')}`; return;
+  }
+  VX.doc = d; VX.fixture = d.fixture === true;
+  $('vx-tabbtn').hidden = false;
+  // a summary from ?vx=URL is someone else's file: say so, so a shared link cannot pass as this Space's results
+  if (params.get('vx') && params.get('vx') !== 'fixture') { $('vx-error').hidden = false; $('vx-error').textContent = `Loaded from ${VX.url} (the vx parameter), not this Space's own results.`; }
+  document.querySelectorAll('.vx-fixture').forEach((b) => { b.hidden = !VX.fixture; });
+  document.body.classList.toggle('vx-fx', VX.fixture);
+  renderCards();
+  if (typeof table === 'function') table();
+  const sc = d.showcase || [];
+  $('vx-show-none').hidden = sc.length > 0; $('vx-show').hidden = !sc.length;
+  if (sc.length) {
+    $('vx-show-pick').innerHTML = sc.map((s) => `<option value="${esc(s.segment)}">${esc(s.scroll)} · ${esc(s.segment)}</option>`).join('');
+    $('vx-show-pick').onchange = () => openShowcase($('vx-show-pick').value).catch((e) => { $('vx-show-title').textContent = e.message; });
+    wireShowcase();
+    await openShowcase(sc[0].segment).catch((e) => { $('vx-show-title').textContent = e.message; });
+  }
+  if (params.get('tab') === 'exact') tab('exact');
+}
+
+// the scroll's claim level for the All segments table (app.js)
+window.vxClaim = (scroll) => {
+  if (!VX.doc) return null;
+  const s = VX.doc.scrolls.find((x) => x.scroll === scroll);
+  return s ? VX_CLAIMS[s.claim] : 'Not scored';
+};
+
+Object.assign(window.snappedLabels, {
+  voxelExact: () => (VX.doc ? JSON.parse(JSON.stringify(VX.doc)) : null),
+  openShowcase: (segment) => openShowcase(segment),
+});
+
+window.vxReady = vxInit();

vx/fixture/summary.json

@@ -0,0 +1,1042 @@
+{
+ "schema": "snapped-labels/voxel-exact@1",
+ "fixture": true,
+ "generated": "2026-10-28T00:00:00Z",
+ "dataset": {
+  "repo": "SharpMeow/vesuvius-snapped-labels",
+  "release": "1.0.1",
+  "revision": "95432ec570d6f096d754e6ac16cafdeb83ca8a04"
+ },
+ "rule": {
+  "primary_tolerance": 1.0,
+  "tolerances": [
+   0.5,
+   1.0,
+   2.0
+  ],
+  "bar": 0.9,
+  "interval": {
+   "method": "clopper-pearson",
+   "sided": "one",
+   "level": 0.95
+  },
+  "max_move": 16.0
+ },
+ "prereg": {
+  "sha256": "0000000000000000000000000000000000000000000000000000000000000000",
+  "frozen": "2026-10-28T00:00:00Z"
+ },
+ "prizes_read": {
+  "url": "https://scrollprize.org/prizes",
+  "date": "2026-10-28"
+ },
+ "scrolls": [
+  {
+   "scroll": "SYNTH-A",
+   "claim": "measured",
+   "why_not_shown": null,
+   "label_scan": {
+    "volume_id": "synthetic-label-scan",
+    "voxel_um": 9.0
+   },
+   "truth": {
+    "kind": "finer_scan",
+    "volume_id": "synthetic-fine-scan",
+    "voxel_um": 1.1
+   },
+   "oracle": {
+    "kind": "finer_scan",
+    "volume_id": "synthetic-mid-scan",
+    "voxel_um": 2.4
+   },
+   "certificate": null,
+   "vertices": {
+    "released": 120000,
+    "held_back": 18000,
+    "by_code": {
+     "0": 80000,
+     "2": 38800,
+     "1": 1200
+    }
+   },
+   "void": [],
+   "strata": [
+    {
+     "id": "C0",
+     "code": 0,
+     "primary": true,
+     "verdict": "PASS",
+     "instrument_limited": false,
+     "why": "every leg holds",
+     "n_selected": 60,
+     "n_scorable": 58,
+     "within": {
+      "0.5": {
+       "basis": "scorable",
+       "k": 41,
+       "n": 58,
+       "share": 0.706897,
+       "lower": null,
+       "upper": null
+      },
+      "1": {
+       "basis": "itt",
+       "k": 56,
+       "n": 60,
+       "share": 0.933333,
+       "lower": 0.856,
+       "upper": 0.9933
+      },
+      "2": {
+       "basis": "scorable",
+       "k": 58,
+       "n": 58,
+       "share": 1.0,
+       "lower": null,
+       "upper": null
+      }
+     },
+     "median_abs": 0.404,
+     "residual_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       2,
+       1,
+       6,
+       12,
+       12,
+       9,
+       10,
+       4,
+       2,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0
+      ],
+      "under": 0,
+      "over": 0,
+      "sign": "positive: the snapped point lies outward of the truth face, away from the center line"
+     },
+     "published_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       1,
+       0,
+       1,
+       2,
+       1,
+       3,
+       2,
+       0,
+       3,
+       1,
+       3,
+       4,
+       7,
+       5,
+       5,
+       3,
+       3,
+       5,
+       2,
+       1,
+       2
+      ],
+      "under": 0,
+      "over": 4
+     },
+     "controls": [
+      {
+       "name": "published label",
+       "observed": 0.22,
+       "require": "below",
+       "limit": 0.6,
+       "holds": true
+      },
+      {
+       "name": "planted +1.5 voxels",
+       "observed": 0.12,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "planted -1.5 voxels",
+       "observed": 0.15,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "planted +3 voxels",
+       "observed": 0.02,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "verso face",
+       "observed": 0.05,
+       "require": "below",
+       "limit": 0.3,
+       "holds": true
+      },
+      {
+       "name": "oracle face (2.4 um scan)",
+       "observed": 0.97,
+       "require": "above",
+       "limit": 0.8,
+       "holds": true
+      }
+     ]
+    },
+    {
+     "id": "C2",
+     "code": 2,
+     "primary": false,
+     "verdict": "NOT SHOWN",
+     "instrument_limited": false,
+     "why": "the lower bound is under the bar",
+     "n_selected": 60,
+     "n_scorable": 55,
+     "within": {
+      "0.5": {
+       "basis": "scorable",
+       "k": 22,
+       "n": 55,
+       "share": 0.4,
+       "lower": null,
+       "upper": null
+      },
+      "1": {
+       "basis": "itt",
+       "k": 44,
+       "n": 60,
+       "share": 0.733333,
+       "lower": 0.632,
+       "upper": 0.7933
+      },
+      "2": {
+       "basis": "scorable",
+       "k": 52,
+       "n": 55,
+       "share": 0.945455,
+       "lower": null,
+       "upper": null
+      }
+     },
+     "median_abs": 0.907,
+     "residual_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       2,
+       3,
+       3,
+       5,
+       2,
+       6,
+       4,
+       2,
+       5,
+       5,
+       6,
+       4,
+       2,
+       4,
+       1,
+       0,
+       1,
+       0,
+       0,
+       0,
+       0,
+       0
+      ],
+      "under": 0,
+      "over": 0,
+      "sign": "positive: the snapped point lies outward of the truth face, away from the center line"
+     },
+     "published_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       1,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       2,
+       1,
+       2,
+       3,
+       1,
+       4,
+       4,
+       3,
+       4,
+       3,
+       3,
+       8,
+       2,
+       3,
+       5,
+       1,
+       0,
+       2,
+       0
+      ],
+      "under": 0,
+      "over": 3
+     },
+     "controls": [
+      {
+       "name": "published label",
+       "observed": 0.25,
+       "require": "below",
+       "limit": 0.6,
+       "holds": true
+      },
+      {
+       "name": "planted +1.5 voxels",
+       "observed": 0.12,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "planted -1.5 voxels",
+       "observed": 0.15,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "planted +3 voxels",
+       "observed": 0.02,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "verso face",
+       "observed": 0.05,
+       "require": "below",
+       "limit": 0.3,
+       "holds": true
+      },
+      {
+       "name": "oracle face (2.4 um scan)",
+       "observed": 0.97,
+       "require": "above",
+       "limit": 0.8,
+       "holds": true
+      }
+     ]
+    },
+    {
+     "id": "C1",
+     "code": 1,
+     "primary": false,
+     "verdict": "UNANSWERABLE",
+     "instrument_limited": false,
+     "why": "12 selected sites, under the minimum of 30",
+     "n_selected": 12,
+     "n_scorable": 12,
+     "within": {
+      "0.5": {
+       "basis": "scorable",
+       "k": 2,
+       "n": 12,
+       "share": 0.166667,
+       "lower": null,
+       "upper": null
+      },
+      "1": {
+       "basis": "itt",
+       "k": 5,
+       "n": 12,
+       "share": 0.416667,
+       "lower": null,
+       "upper": 0.4767
+      },
+      "2": {
+       "basis": "scorable",
+       "k": 9,
+       "n": 12,
+       "share": 0.75,
+       "lower": null,
+       "upper": null
+      }
+     },
+     "median_abs": 1.979,
+     "residual_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       1,
+       0,
+       0,
+       0,
+       1,
+       1,
+       0,
+       1,
+       0,
+       2,
+       0,
+       0,
+       1,
+       0,
+       2,
+       0,
+       0,
+       0,
+       1,
+       0,
+       0
+      ],
+      "under": 0,
+      "over": 2,
+      "sign": "positive: the snapped point lies outward of the truth face, away from the center line"
+     },
+     "published_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       2,
+       0,
+       0,
+       0,
+       0,
+       1,
+       0,
+       2,
+       0,
+       1,
+       0,
+       2,
+       1,
+       0,
+       0,
+       1,
+       0,
+       1,
+       0,
+       0
+      ],
+      "under": 0,
+      "over": 1
+     },
+     "controls": [
+      {
+       "name": "published label",
+       "observed": 0.21,
+       "require": "below",
+       "limit": 0.6,
+       "holds": true
+      },
+      {
+       "name": "planted +1.5 voxels",
+       "observed": 0.12,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "planted -1.5 voxels",
+       "observed": 0.15,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "planted +3 voxels",
+       "observed": 0.02,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "verso face",
+       "observed": 0.05,
+       "require": "below",
+       "limit": 0.3,
+       "holds": true
+      },
+      {
+       "name": "oracle face (2.4 um scan)",
+       "observed": 0.97,
+       "require": "above",
+       "limit": 0.8,
+       "holds": true
+      }
+     ]
+    },
+    {
+     "id": "C0L",
+     "code": 0,
+     "primary": false,
+     "verdict": "PASS",
+     "instrument_limited": false,
+     "why": "every leg holds",
+     "n_selected": 60,
+     "n_scorable": 59,
+     "within": {
+      "0.5": {
+       "basis": "scorable",
+       "k": 38,
+       "n": 59,
+       "share": 0.644068,
+       "lower": null,
+       "upper": null
+      },
+      "1": {
+       "basis": "itt",
+       "k": 55,
+       "n": 60,
+       "share": 0.916667,
+       "lower": 0.835,
+       "upper": 0.9767
+      },
+      "2": {
+       "basis": "scorable",
+       "k": 59,
+       "n": 59,
+       "share": 1.0,
+       "lower": null,
+       "upper": null
+      }
+     },
+     "median_abs": 0.571,
+     "residual_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       1,
+       0,
+       5,
+       4,
+       11,
+       9,
+       10,
+       7,
+       7,
+       1,
+       1,
+       3,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0
+      ],
+      "under": 0,
+      "over": 0,
+      "sign": "positive: the snapped point lies outward of the truth face, away from the center line"
+     },
+     "published_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       1,
+       0,
+       0,
+       0,
+       5,
+       2,
+       4,
+       2,
+       5,
+       3,
+       7,
+       2,
+       5,
+       1,
+       0,
+       1,
+       5,
+       6,
+       4,
+       2
+      ],
+      "under": 0,
+      "over": 4
+     },
+     "controls": [
+      {
+       "name": "published label",
+       "observed": 0.24,
+       "require": "below",
+       "limit": 0.6,
+       "holds": true
+      },
+      {
+       "name": "planted +1.5 voxels",
+       "observed": 0.12,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "planted -1.5 voxels",
+       "observed": 0.15,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "planted +3 voxels",
+       "observed": 0.02,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "verso face",
+       "observed": 0.05,
+       "require": "below",
+       "limit": 0.3,
+       "holds": true
+      },
+      {
+       "name": "oracle face (2.4 um scan)",
+       "observed": 0.97,
+       "require": "above",
+       "limit": 0.8,
+       "holds": true
+      }
+     ]
+    }
+   ]
+  },
+  {
+   "scroll": "SYNTH-B",
+   "claim": "certified",
+   "why_not_shown": null,
+   "label_scan": {
+    "volume_id": "synthetic-label-scan-b",
+    "voxel_um": 7.9
+   },
+   "truth": null,
+   "oracle": null,
+   "certificate": {
+    "method": "synthetic two-face agreement bound",
+    "lower": 0.81,
+    "level": 0.95,
+    "n": 5000,
+    "assumptions": [
+     "Made-up assumption one: the two faces err independently.",
+     "Made-up assumption two: the sampled vertices represent the scroll."
+    ]
+   },
+   "vertices": {
+    "released": 90000,
+    "held_back": 9000,
+    "by_code": {
+     "0": 70000,
+     "2": 19000,
+     "1": 1000
+    }
+   },
+   "void": [],
+   "strata": []
+  },
+  {
+   "scroll": "SYNTH-C",
+   "claim": "not_shown",
+   "why_not_shown": "no finer scan and the certificate's assumptions did not hold (synthetic example)",
+   "label_scan": {
+    "volume_id": "synthetic-label-scan-c",
+    "voxel_um": 9.0
+   },
+   "truth": null,
+   "oracle": null,
+   "certificate": null,
+   "vertices": {
+    "released": 40000,
+    "held_back": 4000,
+    "by_code": {
+     "0": 22000,
+     "2": 16000,
+     "1": 2000
+    }
+   },
+   "void": [],
+   "strata": []
+  }
+ ],
+ "showcase": [
+  {
+   "scroll": "SYNTH-A",
+   "segment": "synthetic-sheet",
+   "file": "show/SYNTH-A/synthetic-sheet.json",
+   "spent": true
+  }
+ ]
+}

vx/summary.json

@@ -0,0 +1,1049 @@
+{
+ "schema": "snapped-labels/voxel-exact@1",
+ "fixture": false,
+ "generated": "2026-10-28T07:10:00Z",
+ "dataset": {
+  "repo": "SharpMeow/vesuvius-snapped-labels",
+  "release": "1.0.1",
+  "revision": "95432ec570d6f096d754e6ac16cafdeb83ca8a04"
+ },
+ "rule": {
+  "primary_tolerance": 1.0,
+  "tolerances": [
+   0.5,
+   1.0,
+   2.0
+  ],
+  "bar": 0.9,
+  "interval": {
+   "method": "clopper-pearson",
+   "sided": "one",
+   "level": 0.95
+  },
+  "max_move": 16.0
+ },
+ "prereg": {
+  "sha256": "bcac8e074d03c75ece811bee91688ce8682b5aad8c820e2b0e77003207c1d52a",
+  "frozen": "2026-10-28T02:40:03Z"
+ },
+ "prizes_read": {
+  "url": "https://scrollprize.org/prizes",
+  "date": "2026-10-28"
+ },
+ "scrolls": [
+  {
+   "scroll": "PHerc0139",
+   "claim": "not_shown",
+   "why_not_shown": "the frozen test gave NOT SHOWN for every class, so no class clears the bar, and the finer reference scan does not clear it either, so the instrument limits this test",
+   "label_scan": {
+    "volume_id": "20250728140407",
+    "voxel_um": 9.362
+   },
+   "truth": {
+    "kind": "finer_scan",
+    "volume_id": "20260413113053",
+    "voxel_um": 1.129
+   },
+   "oracle": {
+    "kind": "finer_scan",
+    "volume_id": "20260102150214",
+    "voxel_um": 2.399
+   },
+   "certificate": null,
+   "vertices": {
+    "released": 3147195,
+    "held_back": 872310,
+    "by_code": {
+     "0": 2758538,
+     "2": 373639,
+     "1": 15018
+    }
+   },
+   "void": [],
+   "strata": [
+    {
+     "id": "C0",
+     "code": 0,
+     "primary": true,
+     "verdict": "NOT SHOWN",
+     "instrument_limited": true,
+     "why": "no PASS, since the lower bound 70.5% is under the 90% bar, and no FAIL, since 10 sites are certain misses where a FAIL needs 28; 152 of 200 sites within 1 voxel counting each unscorable site as a miss, 18 scorable sites missed and 30 not scorable; the 2.399 µm scan's own face reaches a lower bound of 68.4% at the same sites; sites in z 4680 to 5184 of the label scan, one vertex each, drawn after the rule was frozen",
+     "n_selected": 200,
+     "n_scorable": 170,
+     "within": {
+      "0.5": null,
+      "1": {
+       "basis": "itt",
+       "k": 152,
+       "n": 200,
+       "share": 0.76,
+       "lower": 0.7051,
+       "upper": 0.809029
+      },
+      "2": {
+       "basis": "scorable",
+       "k": 159,
+       "n": 170,
+       "share": 0.935294,
+       "lower": null,
+       "upper": null
+      }
+     },
+     "median_abs": 0.26771,
+     "residual_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       1,
+       4,
+       5,
+       20,
+       29,
+       52,
+       27,
+       11,
+       4,
+       1,
+       5,
+       0,
+       0,
+       0,
+       0,
+       2,
+       0,
+       0,
+       0,
+       0,
+       0
+      ],
+      "under": 2,
+      "over": 7,
+      "sign": "positive: the snapped point lies outward of the truth face, away from the center line"
+     },
+     "published_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       1,
+       1,
+       0,
+       3,
+       1,
+       4,
+       3,
+       2,
+       4,
+       8,
+       5,
+       1,
+       6,
+       7,
+       10,
+       7,
+       9,
+       8,
+       12,
+       5,
+       8,
+       5,
+       6,
+       0,
+       8,
+       6,
+       1,
+       0
+      ],
+      "under": 1,
+      "over": 38
+     },
+     "controls": [
+      {
+       "name": "published label, C0 test gate (170 scorable sites)",
+       "observed": 0.282353,
+       "require": "below",
+       "limit": 0.6,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved +1.5 voxels, C0 test gate (161 sites)",
+       "observed": 0.049689,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved -1.5 voxels, C0 test gate (161 sites)",
+       "observed": 0.111801,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved +3 voxels, C0 test gate (161 sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved -3 voxels, C0 test gate (161 sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "verso face, C0 test gate (170 scorable sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "positive control: the 2.399 µm scan's own face, C0 test gate (170 scorable sites)",
+       "observed": 0.870588,
+       "require": "above",
+       "limit": 0.75,
+       "holds": true
+      }
+     ]
+    },
+    {
+     "id": "C0L",
+     "code": 0,
+     "primary": false,
+     "verdict": "NOT SHOWN",
+     "instrument_limited": true,
+     "why": "no PASS, since the lower bound 15.1% is under the 90% bar, and no FAIL, since 10 sites are certain misses where a FAIL needs 14; 18 of 80 sites within 1 voxel counting each unscorable site as a miss, 13 scorable sites missed and 49 not scorable; the 2.399 µm scan's own face reaches a lower bound of 0.4% at the same sites; sites in z 4680 to 5184 of the label scan, one vertex each, drawn after the rule was frozen",
+     "n_selected": 80,
+     "n_scorable": 31,
+     "within": {
+      "0.5": null,
+      "1": {
+       "basis": "itt",
+       "k": 18,
+       "n": 80,
+       "share": 0.225,
+       "lower": 0.15076,
+       "upper": 0.315169
+      },
+      "2": {
+       "basis": "scorable",
+       "k": 21,
+       "n": 31,
+       "share": 0.677419,
+       "lower": null,
+       "upper": null
+      }
+     },
+     "median_abs": 0.579733,
+     "residual_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       1,
+       0,
+       0,
+       0,
+       0,
+       0,
+       2,
+       4,
+       4,
+       3,
+       2,
+       1,
+       2,
+       0,
+       1,
+       1,
+       1,
+       2,
+       1,
+       1,
+       0,
+       0,
+       1,
+       0,
+       0
+      ],
+      "under": 0,
+      "over": 4,
+      "sign": "positive: the snapped point lies outward of the truth face, away from the center line"
+     },
+     "published_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       1,
+       0,
+       1,
+       2,
+       0,
+       0,
+       0,
+       0,
+       2,
+       0,
+       2,
+       0,
+       1,
+       1,
+       0,
+       0,
+       0,
+       0,
+       1,
+       0,
+       1,
+       1,
+       1,
+       0,
+       0
+      ],
+      "under": 0,
+      "over": 17
+     },
+     "controls": [
+      {
+       "name": "published label, C0 test gate (170 scorable sites)",
+       "observed": 0.282353,
+       "require": "below",
+       "limit": 0.6,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved +1.5 voxels, C0 test gate (161 sites)",
+       "observed": 0.049689,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved -1.5 voxels, C0 test gate (161 sites)",
+       "observed": 0.111801,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved +3 voxels, C0 test gate (161 sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved -3 voxels, C0 test gate (161 sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "verso face, C0 test gate (170 scorable sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "positive control: the 2.399 µm scan's own face, C0 test gate (170 scorable sites)",
+       "observed": 0.870588,
+       "require": "above",
+       "limit": 0.75,
+       "holds": true
+      }
+     ]
+    },
+    {
+     "id": "C2",
+     "code": 2,
+     "primary": true,
+     "verdict": "NOT SHOWN",
+     "instrument_limited": true,
+     "why": "no PASS, since the lower bound 0.2% is under the 90% bar, and no FAIL, since 22 sites are certain misses where a FAIL needs 28; 2 of 200 sites within 1 voxel counting each unscorable site as a miss, 38 scorable sites missed and 160 not scorable; the 2.399 µm scan's own face reaches a lower bound of 0.0% at the same sites; sites in z 4680 to 5184 of the label scan, one vertex each, drawn after the rule was frozen",
+     "n_selected": 200,
+     "n_scorable": 40,
+     "within": {
+      "0.5": null,
+      "1": {
+       "basis": "itt",
+       "k": 2,
+       "n": 200,
+       "share": 0.01,
+       "lower": 0.00178,
+       "upper": 0.031143
+      },
+      "2": {
+       "basis": "scorable",
+       "k": 11,
+       "n": 40,
+       "share": 0.275,
+       "lower": null,
+       "upper": null
+      }
+     },
+     "median_abs": 4.643408,
+     "residual_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       1,
+       0,
+       0,
+       0,
+       1,
+       1,
+       1,
+       2,
+       1,
+       1,
+       0,
+       0,
+       0,
+       1,
+       0,
+       0,
+       0,
+       1,
+       1,
+       0,
+       1,
+       2,
+       0,
+       0,
+       0,
+       1,
+       2,
+       0,
+       1,
+       1
+      ],
+      "under": 6,
+      "over": 15,
+      "sign": "positive: the snapped point lies outward of the truth face, away from the center line"
+     },
+     "published_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       1,
+       0,
+       0,
+       0,
+       0,
+       2,
+       0,
+       1,
+       2,
+       0,
+       1,
+       0,
+       0,
+       0,
+       0,
+       1,
+       0,
+       0,
+       2,
+       1,
+       0,
+       0,
+       0,
+       0,
+       0,
+       1,
+       0,
+       0,
+       0,
+       1,
+       0,
+       1
+      ],
+      "under": 1,
+      "over": 25
+     },
+     "controls": [
+      {
+       "name": "published label, C0 test gate (170 scorable sites)",
+       "observed": 0.282353,
+       "require": "below",
+       "limit": 0.6,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved +1.5 voxels, C0 test gate (161 sites)",
+       "observed": 0.049689,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved -1.5 voxels, C0 test gate (161 sites)",
+       "observed": 0.111801,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved +3 voxels, C0 test gate (161 sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved -3 voxels, C0 test gate (161 sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "verso face, C0 test gate (170 scorable sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "positive control: the 2.399 µm scan's own face, C0 test gate (170 scorable sites)",
+       "observed": 0.870588,
+       "require": "above",
+       "limit": 0.75,
+       "holds": true
+      }
+     ]
+    },
+    {
+     "id": "C1",
+     "code": 1,
+     "primary": true,
+     "verdict": "NOT SHOWN",
+     "instrument_limited": true,
+     "why": "no PASS, since the lower bound 0.0% is under the 90% bar, and no FAIL, since 0 sites are certain misses where a FAIL needs 28; 0 of 200 sites within 1 voxel counting each unscorable site as a miss, 2 scorable sites missed and 198 not scorable; the 2.399 µm scan's own face reaches a lower bound of 0.0% at the same sites; sites in z 4680 to 5184 of the label scan, one vertex each, drawn after the rule was frozen",
+     "n_selected": 200,
+     "n_scorable": 2,
+     "within": {
+      "0.5": null,
+      "1": {
+       "basis": "itt",
+       "k": 0,
+       "n": 200,
+       "share": 0.0,
+       "lower": 0.0,
+       "upper": 0.014867
+      },
+      "2": {
+       "basis": "scorable",
+       "k": 0,
+       "n": 2,
+       "share": 0.0,
+       "lower": null,
+       "upper": null
+      }
+     },
+     "median_abs": 13.756861,
+     "residual_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0
+      ],
+      "under": 0,
+      "over": 2,
+      "sign": "positive: the snapped point lies outward of the truth face, away from the center line"
+     },
+     "published_hist": {
+      "edges": [
+       -4.0,
+       -3.75,
+       -3.5,
+       -3.25,
+       -3.0,
+       -2.75,
+       -2.5,
+       -2.25,
+       -2.0,
+       -1.75,
+       -1.5,
+       -1.25,
+       -1.0,
+       -0.75,
+       -0.5,
+       -0.25,
+       0.0,
+       0.25,
+       0.5,
+       0.75,
+       1.0,
+       1.25,
+       1.5,
+       1.75,
+       2.0,
+       2.25,
+       2.5,
+       2.75,
+       3.0,
+       3.25,
+       3.5,
+       3.75,
+       4.0
+      ],
+      "counts": [
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       0
+      ],
+      "under": 0,
+      "over": 2
+     },
+     "controls": [
+      {
+       "name": "published label, C0 test gate (170 scorable sites)",
+       "observed": 0.282353,
+       "require": "below",
+       "limit": 0.6,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved +1.5 voxels, C0 test gate (161 sites)",
+       "observed": 0.049689,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved -1.5 voxels, C0 test gate (161 sites)",
+       "observed": 0.111801,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved +3 voxels, C0 test gate (161 sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "2.399 µm face moved -3 voxels, C0 test gate (161 sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.2,
+       "holds": true
+      },
+      {
+       "name": "verso face, C0 test gate (170 scorable sites)",
+       "observed": 0.0,
+       "require": "below",
+       "limit": 0.5,
+       "holds": true
+      },
+      {
+       "name": "positive control: the 2.399 µm scan's own face, C0 test gate (170 scorable sites)",
+       "observed": 0.870588,
+       "require": "above",
+       "limit": 0.75,
+       "holds": true
+      }
+     ]
+    }
+   ]
+  },
+  {
+   "scroll": "PHerc0814",
+   "claim": "not_shown",
+   "why_not_shown": "not tested yet: no frozen voxel-exact test has run on this scroll",
+   "label_scan": {
+    "volume_id": "20250804134230",
+    "voxel_um": 9.362
+   },
+   "truth": null,
+   "oracle": null,
+   "certificate": null,
+   "vertices": {
+    "released": 1143812,
+    "held_back": 226239,
+    "by_code": {
+     "0": 956569,
+     "2": 179773,
+     "1": 7470
+    }
+   },
+   "void": [],
+   "strata": []
+  },
+  {
+   "scroll": "PHerc0841",
+   "claim": "not_shown",
+   "why_not_shown": "not tested yet: no frozen voxel-exact test has run on this scroll",
+   "label_scan": {
+    "volume_id": "20250821151531",
+    "voxel_um": 9.366
+   },
+   "truth": null,
+   "oracle": null,
+   "certificate": null,
+   "vertices": {
+    "released": 73856,
+    "held_back": 0,
+    "by_code": {
+     "0": 58582,
+     "2": 15106,
+     "1": 168
+    }
+   },
+   "void": [],
+   "strata": []
+  },
+  {
+   "scroll": "PHerc0172",
+   "claim": "not_shown",
+   "why_not_shown": "not tested yet: no frozen voxel-exact test has run on this scroll, which was snapped in its own label scan",
+   "label_scan": {
+    "volume_id": "20241024131838",
+    "voxel_um": 7.91
+   },
+   "truth": null,
+   "oracle": null,
+   "certificate": null,
+   "vertices": {
+    "released": 28579231,
+    "held_back": 0,
+    "by_code": {
+     "0": 17954644,
+     "2": 10317309,
+     "1": 307278
+    }
+   },
+   "void": [],
+   "strata": []
+  }
+ ],
+ "showcase": []
+}