leaderboard: serve GT report assets via proxy; link them in hosted report

Add a /gt/{fixture}/{relpath} proxy route that streams the private GT view
PNGs + PDF (token-holding), and pass gt_base_url/input_base_url to
generate_html in the merge path so the hosted report links GT/input/overlay
(lazy) instead of base64-inlining them. Bump CADGENBENCH_SHA to 25943a0.

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

Dockerfile

@@ -41,7 +41,7 @@ RUN pip install --no-cache-dir -r /tmp/requirements.txt \
 # image rebuild picks up the latest code (pre-v1: always-updated). Lock
 # to a specific commit SHA at the v1 release so published scores are
 # reproducible (see space-setup/post-gt-swap.md Stage F).
-ARG CADGENBENCH_SHA=3d49822
+ARG CADGENBENCH_SHA=25943a0
 # Cache-bust the install below whenever the tracked ref moves: the
 # GitHub commits endpoint's response changes with each new commit on
 # `main`, so BuildKit re-fetches and invalidates the cached pip layer.

app.py

@@ -609,6 +609,52 @@ def serve_gt_render(fixture: str) -> Response:
     )
 
 
+def _fetch_gt_file(fixture: str, relpath: str) -> bytes | None:
+    """Pull an arbitrary GT asset (``<fixture>/<relpath>``) from the GT dataset.
+
+    Serves the hosted report's ground-truth column: the per-view PNGs
+    (``renders/<view>.png``) and the ``ground_truth.pdf``. The GT dataset is
+    **private**, so these are proxied through the Space (which holds the read
+    token) rather than linked directly. ``hf_hub_download`` does the
+    per-revision disk cache. Returns ``None`` on any failure (the report hides
+    the broken tile via the browser's normal missing-image handling).
+    """
+    try:
+        local_path = hf_hub_download(
+            repo_id=HF_DATA_GT_REPO,
+            filename=f"{fixture}/{relpath}",
+            repo_type="dataset",
+        )
+        return Path(local_path).read_bytes()
+    except Exception as e:  # noqa: BLE001 - any Hub failure -> 404
+        logger.warning(
+            "Failed to fetch GT file %s/%s (%s: %s)",
+            fixture, relpath, type(e).__name__, e,
+        )
+        return None
+
+
+def serve_gt_file(fixture: str, relpath: str) -> Response:
+    """Stream a GT asset (view PNG / PDF) with long-lived immutable caching.
+
+    Path-traversal-guarded (``..`` rejected). The hosted report references
+    ``/gt/<fixture>/<relpath>`` and the browser fetches it lazily; the bytes
+    are a property of the data revision (not any submission), so the same
+    immutable ``Cache-Control`` as the render/input proxies applies.
+    """
+    if ".." in fixture or ".." in relpath:
+        return Response(status_code=404)
+    data = _fetch_gt_file(fixture, relpath)
+    if data is None:
+        return Response(status_code=404)
+    media_type = mimetypes.guess_type(relpath)[0] or "application/octet-stream"
+    return Response(
+        content=data,
+        media_type=media_type,
+        headers={"Cache-Control": RENDER_CACHE_CONTROL},
+    )
+
+
 def _gallery_iframe_html() -> str:
     """Build the gallery as a self-contained ``srcdoc`` iframe.
 
@@ -1075,6 +1121,15 @@ app.add_api_route(
     serve_gt_render,
     methods=["GET"],
 )
+# Ground-truth assets the hosted report links lazily (per-view PNGs + PDF).
+# GT is private, so this token-holding proxy streams them; the `:path`
+# converter lets `relpath` carry a slash (e.g. renders/iso.png). Registered
+# before the Gradio mount so it isn't shadowed by the catch-all sub-app.
+app.add_api_route(
+    "/gt/{fixture}/{relpath:path}",
+    serve_gt_file,
+    methods=["GET"],
+)
 # Task-browser input assets (drawings + starting-shape renders). The
 # `:path` converter lets `relpath` carry a slash (e.g. renders/iso.png).
 # Registered before the Gradio mount so it's not shadowed.

submit.py

@@ -139,6 +139,11 @@ SUBMISSION_ID_SLUG_MAX = 40
 RESULTS_FILENAME = "results.jsonl"
 SUBMISSIONS_DIR = "submissions"
 REPORTS_DIR = "reports"
+# Space-relative proxy roots the hosted report links its *private* assets
+# through (GT + inputs can't be public-bucket URLs). Must match the routes
+# registered in app.py and the constants in the eval job's eval_job.py.
+GT_PROXY_BASE_URL = "/gt"
+INPUT_PROXY_BASE_URL = "/task-input"
 DATA_REV_SHORT_LEN = 12
 FAILURE_REASON_MAX_CHARS = 200
 SHA256_BLOCK_SIZE = 64 * 1024
@@ -1536,11 +1541,16 @@ def _merge_shards_and_publish(
         report_json = _build_report_json(merged_run)
 
         run_data = discover_run(merged_run)
-        # Hosted report references the candidate renders from the public bucket
-        # (uploaded by the shard jobs), keeping the heavy WebP/PNG bytes out of
-        # the committed HTML. GT/input stay inlined (GT is private).
+        # Hosted report links every heavy asset (lazy-loaded) instead of
+        # base64-inlining it, so the committed HTML stays small: candidate
+        # renders + interface overlay come from the public bucket (uploaded by
+        # the shard jobs); GT views + inputs are private, so they link through
+        # the Space's token-holding proxy routes.
         html = generate_html(
-            run_data, render_base_url=render_submission_base_url(submission_id),
+            run_data,
+            render_base_url=render_submission_base_url(submission_id),
+            gt_base_url=GT_PROXY_BASE_URL,
+            input_base_url=INPUT_PROXY_BASE_URL,
         )
         html_path = tmp / f"{submission_id}.html"
         html_path.write_text(html, encoding="utf-8")