leaderboard: show edit-diff turntable in gallery grid for editing fixtures

The gallery grid tile for an editing fixture now serves the ghost edit-diff
WebP (renders/<id>/<fixture>/edit_diff.webp) instead of the plain candidate
turntable, so a small edit is legible at a glance. Generation tiles, the GT
column, and the cell-click modal are unchanged (the modal keeps the plain
aligned output via img; the grid uses a new gridImg).

- gallery: per-cell gridImg + gridRenderFor hook; build/render take a
diff_resolver.
- app: _fetch_render_diff + /render-diff proxy route + resolver. A miss 404s
to the dashed cell (no fallback to rotating.webp).

Co-authored-by: Cursor <cursoragent@cursor.com>

app.py

@@ -555,6 +555,29 @@ def _fetch_render(submission_id: str, fixture: str) -> bytes | None:
         return None
 
 
+def _fetch_render_diff(submission_id: str, fixture: str) -> bytes | None:
+    """Pull a submission's edit-diff turntable (``renders/<id>/<fixture>/edit_diff.webp``).
+
+    Editing fixtures only; the evaluator writes this alongside the plain
+    ``rotating.webp``. Same no-memoization rationale as :func:`_fetch_render`.
+    Returns ``None`` on any failure, including the expected miss for
+    non-editing fixtures, so the gallery degrades to the dashed cell.
+    """
+    try:
+        local_path = hf_hub_download(
+            repo_id=HF_SUBMISSIONS_REPO,
+            filename=f"renders/{submission_id}/{fixture}/edit_diff.webp",
+            repo_type="dataset",
+        )
+        return Path(local_path).read_bytes()
+    except Exception as e:  # noqa: BLE001 - any Hub failure -> 404
+        logger.warning(
+            "Failed to fetch edit-diff render %s/%s (%s: %s)",
+            submission_id, fixture, type(e).__name__, e,
+        )
+        return None
+
+
 def _fetch_gt_render(fixture: str) -> bytes | None:
     """Pull a fixture's ground-truth GIF from the private GT dataset.
 
@@ -606,6 +629,17 @@ def _render_proxy_url(submission_id: str, fixture: str) -> str | None:
     return f"/render/{submission_id}/{fixture}.webp"
 
 
+def _render_diff_proxy_url(submission_id: str, fixture: str) -> str | None:
+    """Resolver returning the cached proxy URL for a submission's edit-diff WebP.
+
+    Used by the gallery grid for editing fixtures (see
+    ``gallery.build_gallery_payload``). A miss (non-editing fixture, or an edit
+    that never rendered a diff) 404s and degrades to the dashed cell client-side
+    via the ``<img onerror>`` hook, no fallback to the plain turntable.
+    """
+    return f"/render-diff/{submission_id}/{fixture}.webp"
+
+
 def _gt_proxy_url(fixture: str) -> str | None:
     """Resolver returning the cached proxy URL for a fixture's GT WebP."""
     return f"/gt-render/{fixture}.webp"
@@ -629,6 +663,18 @@ def serve_render(submission_id: str, fixture: str) -> Response:
     )
 
 
+def serve_render_diff(submission_id: str, fixture: str) -> Response:
+    """Stream a submission's edit-diff turntable WebP with long-lived caching."""
+    webp = _fetch_render_diff(submission_id, fixture)
+    if webp is None:
+        return Response(status_code=404)
+    return Response(
+        content=webp,
+        media_type="image/webp",
+        headers={"Cache-Control": RENDER_CACHE_CONTROL},
+    )
+
+
 def serve_gt_render(fixture: str) -> Response:
     """Stream a fixture's ground-truth render WebP with long-lived caching."""
     webp = _fetch_gt_render(fixture)
@@ -656,7 +702,9 @@ def _gallery_iframe_html() -> str:
     except LeaderboardDataError:
         logger.exception("Gallery row load failed; rendering empty gallery")
         rows = []
-    doc = render_gallery_page(rows, _render_proxy_url, _gt_proxy_url)
+    doc = render_gallery_page(
+        rows, _render_proxy_url, _gt_proxy_url, _render_diff_proxy_url,
+    )
     escaped = html.escape(doc, quote=True)
     return (
         f'<iframe srcdoc="{escaped}" '
@@ -1102,6 +1150,11 @@ app.add_api_route(
     serve_render,
     methods=["GET"],
 )
+app.add_api_route(
+    "/render-diff/{submission_id}/{fixture}.webp",
+    serve_render_diff,
+    methods=["GET"],
+)
 app.add_api_route(
     "/gt-render/{fixture}.webp",
     serve_gt_render,

gallery.py

@@ -97,7 +97,7 @@ def _fixture_universe(rows: list[dict]) -> list[dict]:
     ]
 
 
-def _sub_payload(row: dict, render_resolver) -> dict:
+def _sub_payload(row: dict, render_resolver, diff_resolver) -> dict:
     """Project one verified row into the compact shape the page JS needs.
 
     ``render_resolver(submission_id, fixture_id)`` returns the cached
@@ -105,6 +105,13 @@ def _sub_payload(row: dict, render_resolver) -> dict:
     fixtures carry ``img: null`` so the page draws the dashed cell;
     note validity is driven by the per-fixture ``status`` in the data,
     not by whether an image fetch happened to succeed.
+
+    Each cell also carries ``gridImg``, the source the gallery grid tile
+    uses: for ``editing`` fixtures this is the ghost edit-diff turntable
+    (``diff_resolver``) so the grid shows what actually changed; for every
+    other task it is the same plain candidate turntable as ``img``. The
+    modal keeps using ``img`` (the plain aligned output), so swapping the
+    grid never changes the modal.
     """
     by_task = row.get("score_by_task_type") or {}
     pfs = row.get("per_fixture_scores") or {}
@@ -113,10 +120,16 @@ def _sub_payload(row: dict, render_resolver) -> dict:
     for fid, fx in pfs.items():
         fx = fx or {}
         status = fx.get("status") or "missing"
+        valid = status == "valid"
+        is_editing = (fx.get("task_type") or "") == "editing"
         cells[fid] = {
             "status": status,
             "cad": fx.get("cad_score"),
-            "img": render_resolver(sid, fid) if status == "valid" else None,
+            "img": render_resolver(sid, fid) if valid else None,
+            "gridImg": (
+                (diff_resolver(sid, fid) if is_editing else render_resolver(sid, fid))
+                if valid else None
+            ),
         }
     return {
         "id": sid,
@@ -133,13 +146,16 @@ def _sub_payload(row: dict, render_resolver) -> dict:
     }
 
 
-def build_gallery_payload(rows: list[dict], render_resolver, gt_resolver) -> dict:
+def build_gallery_payload(rows: list[dict], render_resolver, gt_resolver, diff_resolver) -> dict:
     """Shape live rows into the JSON the gallery page renders from.
 
-    Image sources are injected via two resolvers so this module stays
+    Image sources are injected via resolvers so this module stays
     agnostic to how the cached render URLs are constructed:
 
-    - ``render_resolver(submission_id, fixture_id) -> str | None``
+    - ``render_resolver(submission_id, fixture_id) -> str | None`` (plain
+      candidate turntable; backs the modal and non-editing grid tiles)
+    - ``diff_resolver(submission_id, fixture_id) -> str | None`` (edit-diff
+      turntable; backs the grid tile for editing fixtures)
     - ``gt_resolver(fixture_id) -> str | None``
 
     Returns ``{"fixtures", "subs", "selected", "gtImg"}`` where
@@ -152,24 +168,24 @@ def build_gallery_payload(rows: list[dict], render_resolver, gt_resolver) -> dic
     gt_img = {f["id"]: gt_resolver(f["id"]) for f in fixtures}
     return {
         "fixtures": fixtures,
-        "subs": [_sub_payload(r, render_resolver) for r in verified],
+        "subs": [_sub_payload(r, render_resolver, diff_resolver) for r in verified],
         "selected": selected,
         "gtImg": gt_img,
     }
 
 
-def render_gallery_page(rows: list[dict], render_resolver, gt_resolver) -> str:
+def render_gallery_page(rows: list[dict], render_resolver, gt_resolver, diff_resolver) -> str:
     """Build the full standalone gallery HTML document from live rows.
 
-    ``render_resolver`` / ``gt_resolver`` supply the cached render-proxy
-    URLs (see :func:`build_gallery_payload`); the browser lazy-loads only
-    the on-screen turntables.
+    ``render_resolver`` / ``gt_resolver`` / ``diff_resolver`` supply the
+    cached render-proxy URLs (see :func:`build_gallery_payload`); the
+    browser lazy-loads only the on-screen turntables.
 
     The document is self-contained and uses **system font stacks only**
     (no external font CDN fetch) so it never errors inside a sandboxed
     iframe.
     """
-    payload = build_gallery_payload(rows, render_resolver, gt_resolver)
+    payload = build_gallery_payload(rows, render_resolver, gt_resolver, diff_resolver)
     data_json = json.dumps(payload, ensure_ascii=False)
     return (
         "<!DOCTYPE html><html lang='en'><head>"
@@ -456,6 +472,13 @@ function renderFor(sub, fxId) {
   const c = sub.cells[fxId];
   return c ? c.img : null;
 }
+// Grid tiles use gridImg (the edit-diff turntable for editing fixtures, the
+// plain candidate turntable otherwise); the modal keeps renderFor (img), so
+// the grid swap never changes the modal.
+function gridRenderFor(sub, fxId) {
+  const c = sub.cells[fxId];
+  return c ? (c.gridImg || c.img) : null;
+}
 function gtRenderFor(fxId) {
   return (DATA.gtImg || {})[fxId] || null;
 }
@@ -660,7 +683,7 @@ function buildGallery() {
       + '<div class="score-cell"><span class="agg">' + fmt(s.score, 3) + '</span>'
       + '<span class="validity ' + imperfect + '">' + pct(s.validity) + ' <span class="vlabel">valid</span></span></div>';
     selected.forEach(id => {
-      cells += '<div class="thumb-cell">' + thumbHTML(renderFor(s, id), 'data-sub="' + esc(s.id) + '" data-fix="' + esc(id) + '"', true) + '</div>';
+      cells += '<div class="thumb-cell">' + thumbHTML(gridRenderFor(s, id), 'data-sub="' + esc(s.id) + '" data-fix="' + esc(id) + '"', true) + '</div>';
     });
     cells += '<div class="row-toggle" data-toggle="' + esc(s.id) + '">more numbers <span class="chev">&#9662;</span></div>';
     cells += '<div class="detail" id="detail-' + esc(s.id) + '">'