feat: launch AVI-Bench community leaderboard

CONTRIBUTING.md

@@ -0,0 +1,22 @@
+# Contributing leaderboard results
+
+Submit results as a pull request to this Space repository. A maintainer reviews the source and whether the record is complete and credible before merging it. The leaderboard shows the source type; a merged entry is not presented as an independent reproduction.
+
+## Add a result
+
+1. Copy `templates/result-entry.json` into `data/results.json` as a new object in the `entries` array.
+2. Replace every example value, including the `null` score and sample-count placeholders. Use a unique, stable `id`; keep separate records for different model versions or evaluation runs.
+3. Set `source.type` to `paper`, `participant`, or `maintainer`, and link the paper or result report in `source.url`. Use `paper-2606.07643` for results from the paper's benchmark setting; future benchmark releases should use their published release identifier.
+4. Use scores on a 0–100 scale. Set `coverage.status` to `full` only when all tasks in that benchmark release were evaluated. If sample counts are known, report both counts; a full result must cover all reported samples. Partial results and records without an overall score are displayed without a rank.
+5. Open a pull request in this Space repository. Keep the change limited to `data/results.json`; do not include examples, media, ground-truth labels, raw model responses, API keys, or other credentials.
+
+## Required information
+
+- Display name, provider, exact model identifier, and benchmark release.
+- Source type and a public source link.
+- Task coverage and any available evaluation date.
+- Overall score for a row to be ranked. Stage, taxonomy, and task scores may still be submitted without an overall score when the source does not report one; that row remains visible without a rank.
+
+The initial paper entries use the model labels as written in the paper. Their dated API snapshots and sample coverage were not reported in the headline table, so these fields remain unspecified rather than inferred.
+
+The maintainer runs `python validate_results.py` before merging. A source link and complete metadata help reviewers assess credibility; the maintainer may ask for clarification or decline a record that cannot be checked.

DEPLOYMENT.md

@@ -0,0 +1,24 @@
+# Deploy the leaderboard Space
+
+This directory contains the leaderboard files for the existing `FudanCVL/AVI-Bench` Space. The app is a static HTML Space: it reads `data/results.json` in the browser and does not need an inference endpoint, server, or API key.
+
+## First publication
+
+1. Upload the files in this directory to the root of `https://huggingface.co/spaces/FudanCVL/AVI-Bench`, keeping `data/` and `templates/` as directories. This replaces the current starter `README.md` and `index.html`; existing `style.css` and `.gitattributes` are left alone.
+2. Keep the Space **Public** and its SDK set to **Static**.
+3. In the Space repository settings, make sure community pull requests and discussions are enabled.
+4. Confirm that the Space displays the seven paper-reported model entries and that the submission guide is visible.
+
+Hugging Face Static Spaces serve HTML directly without compute. Their repository PRs work across repository types, including Spaces. See the [Static HTML Spaces guide](https://huggingface.co/docs/hub/spaces-sdks-static) and [Pull requests and Discussions guide](https://huggingface.co/docs/hub/repositories-pull-requests-discussions).
+
+## Reviewing updates
+
+For each result PR, inspect the `data/results.json` diff and the linked source, check the model identifier, benchmark release, coverage, and reported metrics, then run:
+
+```bash
+python3 validate_results.py
+```
+
+Merge only after the source and record can be checked. A merged result retains its source label and is not described as an independent reproduction unless one was performed.
+
+Do not accept benchmark examples, media, labels, raw model responses, or credentials in a result PR.

README.md

@@ -1,11 +1,16 @@
 ---
-title: AVI Bench
-emoji: 🌍
-colorFrom: gray
-colorTo: pink
+title: AVI-Bench Leaderboard
+emoji: 🏆
+colorFrom: red
+colorTo: yellow
 sdk: static
+app_file: index.html
 pinned: false
 license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AVI-Bench Leaderboard
+
+Community-submitted results for AVI-Bench, seeded with seven model entries from the paper's headline tables. Results are shown after a maintainer reviews and merges the pull request. The source type identifies whether a score is reported by a paper, a participant, or the maintainers; acceptance does not mean the result was independently reproduced.
+
+See [`CONTRIBUTING.md`](CONTRIBUTING.md) for the score format and pull request instructions, and [`DEPLOYMENT.md`](DEPLOYMENT.md) for Space setup and maintenance.

data/results.json

@@ -0,0 +1,247 @@
+{
+  "schema_version": 1,
+  "entries": [
+    {
+      "id": "gemini-2-5-pro-paper-2606-07643",
+      "model_name": "Gemini-2.5-Pro",
+      "provider": "Google",
+      "model_id": "Gemini-2.5-Pro (paper label)",
+      "benchmark_version": "paper-2606.07643",
+      "source": {
+        "type": "paper",
+        "url": "https://arxiv.org/abs/2606.07643"
+      },
+      "evaluation_date": null,
+      "coverage": {
+        "status": "full",
+        "tasks_completed": 14,
+        "tasks_total": 14,
+        "samples_completed": null,
+        "samples_total": null
+      },
+      "scores": {
+        "overall": 57.21,
+        "stages": {
+          "perception": 54.58,
+          "understanding": 68.97,
+          "reasoning": 69.06,
+          "sensation": 36.22
+        },
+        "taxonomy": {
+          "l1_task": 64.2,
+          "l2_modality": 62.8,
+          "l3_stage": 57.08,
+          "l4_domain": 32.97
+        },
+        "tasks": {}
+      },
+      "notes": "Paper-reported scores. The paper table does not specify a dated API snapshot or sample coverage."
+    },
+    {
+      "id": "gemini-2-5-flash-paper-2606-07643",
+      "model_name": "Gemini-2.5-Flash",
+      "provider": "Google",
+      "model_id": "Gemini-2.5-Flash (paper label)",
+      "benchmark_version": "paper-2606.07643",
+      "source": {
+        "type": "paper",
+        "url": "https://arxiv.org/abs/2606.07643"
+      },
+      "evaluation_date": null,
+      "coverage": {
+        "status": "full",
+        "tasks_completed": 14,
+        "tasks_total": 14,
+        "samples_completed": null,
+        "samples_total": null
+      },
+      "scores": {
+        "overall": 46.02,
+        "stages": {
+          "perception": 45.97,
+          "understanding": 43.79,
+          "reasoning": 63.7,
+          "sensation": 30.63
+        },
+        "taxonomy": {
+          "l1_task": 51.15,
+          "l2_modality": 48.58,
+          "l3_stage": 40.47,
+          "l4_domain": 27.72
+        },
+        "tasks": {}
+      },
+      "notes": "Paper-reported scores. The paper table does not specify a dated API snapshot or sample coverage."
+    },
+    {
+      "id": "gemini-2-flash-paper-2606-07643",
+      "model_name": "Gemini-2.0-Flash",
+      "provider": "Google",
+      "model_id": "Gemini-2.0-Flash (paper label)",
+      "benchmark_version": "paper-2606.07643",
+      "source": {
+        "type": "paper",
+        "url": "https://arxiv.org/abs/2606.07643"
+      },
+      "evaluation_date": null,
+      "coverage": {
+        "status": "full",
+        "tasks_completed": 14,
+        "tasks_total": 14,
+        "samples_completed": null,
+        "samples_total": null
+      },
+      "scores": {
+        "overall": 44.97,
+        "stages": {
+          "perception": 44.27,
+          "understanding": 42.11,
+          "reasoning": 64.03,
+          "sensation": 29.48
+        },
+        "taxonomy": {
+          "l1_task": 50.14,
+          "l2_modality": 49.21,
+          "l3_stage": 39.79,
+          "l4_domain": 27.12
+        },
+        "tasks": {}
+      },
+      "notes": "Paper-reported scores. The paper table does not specify a dated API snapshot or sample coverage."
+    },
+    {
+      "id": "qwen2-5-omni-paper-2606-07643",
+      "model_name": "Qwen2.5-Omni",
+      "provider": "Alibaba Cloud",
+      "model_id": "Qwen2.5-Omni (paper label)",
+      "benchmark_version": "paper-2606.07643",
+      "source": {
+        "type": "paper",
+        "url": "https://arxiv.org/abs/2606.07643"
+      },
+      "evaluation_date": null,
+      "coverage": {
+        "status": "full",
+        "tasks_completed": 14,
+        "tasks_total": 14,
+        "samples_completed": null,
+        "samples_total": null
+      },
+      "scores": {
+        "overall": 41.33,
+        "stages": {
+          "perception": 42.81,
+          "understanding": 39.68,
+          "reasoning": 58.26,
+          "sensation": 24.59
+        },
+        "taxonomy": {
+          "l1_task": 46.92,
+          "l2_modality": 45.93,
+          "l3_stage": 37.61,
+          "l4_domain": 25.89
+        },
+        "tasks": {}
+      },
+      "notes": "Paper-reported scores. The paper table does not specify a dated API snapshot or sample coverage."
+    },
+    {
+      "id": "qwen-omni-turbo-paper-2606-07643",
+      "model_name": "Qwen-Omni-Turbo",
+      "provider": "Alibaba Cloud",
+      "model_id": "Qwen-Omni-Turbo (paper label)",
+      "benchmark_version": "paper-2606.07643",
+      "source": {
+        "type": "paper",
+        "url": "https://arxiv.org/abs/2606.07643"
+      },
+      "evaluation_date": null,
+      "coverage": {
+        "status": "full",
+        "tasks_completed": 14,
+        "tasks_total": 14,
+        "samples_completed": null,
+        "samples_total": null
+      },
+      "scores": {
+        "overall": null,
+        "stages": {},
+        "taxonomy": {
+          "l1_task": 46.5,
+          "l2_modality": 45.15,
+          "l3_stage": 37.7,
+          "l4_domain": 26.13
+        },
+        "tasks": {}
+      },
+      "notes": "Paper reports taxonomy scores only. The paper table does not specify a dated API snapshot or sample coverage."
+    },
+    {
+      "id": "gpt-4o-paper-2606-07643",
+      "model_name": "GPT-4o",
+      "provider": "OpenAI",
+      "model_id": "GPT-4o (paper label)",
+      "benchmark_version": "paper-2606.07643",
+      "source": {
+        "type": "paper",
+        "url": "https://arxiv.org/abs/2606.07643"
+      },
+      "evaluation_date": null,
+      "coverage": {
+        "status": "full",
+        "tasks_completed": 14,
+        "tasks_total": 14,
+        "samples_completed": null,
+        "samples_total": null
+      },
+      "scores": {
+        "overall": 40.68,
+        "stages": {
+          "perception": 40.45,
+          "understanding": 48.6,
+          "reasoning": 56.87,
+          "sensation": 16.81
+        },
+        "taxonomy": {
+          "l1_task": 48.64,
+          "l2_modality": 47.19,
+          "l3_stage": 41.93,
+          "l4_domain": 0.55
+        },
+        "tasks": {}
+      },
+      "notes": "Paper-reported scores. The paper table does not specify a dated API snapshot or sample coverage."
+    },
+    {
+      "id": "baichuan-omni-paper-2606-07643",
+      "model_name": "Baichuan-Omni",
+      "provider": "Baichuan",
+      "model_id": "Baichuan-Omni (paper label)",
+      "benchmark_version": "paper-2606.07643",
+      "source": {
+        "type": "paper",
+        "url": "https://arxiv.org/abs/2606.07643"
+      },
+      "evaluation_date": null,
+      "coverage": {
+        "status": "full",
+        "tasks_completed": 14,
+        "tasks_total": 14,
+        "samples_completed": null,
+        "samples_total": null
+      },
+      "scores": {
+        "overall": null,
+        "stages": {},
+        "taxonomy": {
+          "l1_task": 37.35,
+          "l2_modality": 35.8,
+          "l3_stage": 30.18,
+          "l4_domain": 24.1
+        },
+        "tasks": {}
+      },
+      "notes": "Paper reports taxonomy scores only. The paper table does not specify a dated API snapshot or sample coverage."
+    }
+  ]
+}

index.html

@@ -1,19 +1,570 @@
 <!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="description" content="Community leaderboard for AVI-Bench audio-visual intelligence evaluations.">
+  <meta name="theme-color" content="#f6f1e8">
+  <title>AVI-Bench Leaderboard</title>
+  <style>
+    :root {
+      color-scheme: light;
+      --paper: #f6f1e8;
+      --paper-deep: #ece5d6;
+      --ink: #1a1a1a;
+      --muted: #6c675f;
+      --rule: #d1c7b4;
+      --accent: #8a2422;
+      --accent-soft: #f3e4de;
+      --green: #38604d;
+      --sans: Inter, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      --serif: Georgia, "Times New Roman", serif;
+    }
+
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      background: var(--paper);
+      color: var(--ink);
+      font-family: var(--sans);
+      font-size: 15px;
+      line-height: 1.55;
+    }
+    a { color: var(--accent); text-decoration-thickness: 1px; text-underline-offset: 3px; }
+    a:hover { color: #5f1716; }
+    button, input, select { font: inherit; }
+    .page { width: min(1440px, 100% - 40px); margin: 0 auto; }
+    header { border-bottom: 1px solid var(--rule); }
+    .masthead {
+      min-height: 58px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 16px;
+      color: var(--muted);
+      font-size: 12px;
+      letter-spacing: .12em;
+      text-transform: uppercase;
+    }
+    .brand { color: var(--ink); font-family: var(--serif); font-size: 19px; font-weight: 700; letter-spacing: 0; text-transform: none; }
+    .brand span { color: var(--accent); }
+    .hero { padding: 54px 0 40px; }
+    .eyebrow { margin: 0 0 10px; color: var(--accent); font-size: 11px; font-weight: 700; letter-spacing: .22em; text-transform: uppercase; }
+    h1, h2, h3 { font-family: var(--serif); font-weight: 500; }
+    h1 { margin: 0; font-size: clamp(36px, 6vw, 64px); letter-spacing: -.04em; line-height: 1.02; }
+    .intro { max-width: 760px; margin: 16px 0 0; color: #4c4944; font-family: var(--serif); font-size: 19px; }
+    .links { display: flex; flex-wrap: wrap; gap: 18px; margin-top: 20px; font-size: 13px; }
+    .callout {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto;
+      align-items: center;
+      gap: 18px;
+      margin: 0 0 30px;
+      padding: 18px 20px;
+      border: 1px solid var(--rule);
+      background: rgba(255, 255, 255, .35);
+    }
+    .callout p { margin: 0; color: #45413b; }
+    .button-link {
+      display: inline-block;
+      border: 1px solid var(--ink);
+      padding: 9px 13px;
+      color: var(--ink);
+      font-size: 12px;
+      font-weight: 700;
+      text-decoration: none;
+      white-space: nowrap;
+    }
+    .button-link:hover { background: var(--ink); color: var(--paper); }
+    .section-heading { display: flex; align-items: end; justify-content: space-between; gap: 20px; margin: 0 0 16px; }
+    .section-heading h2 { margin: 0; font-size: 30px; letter-spacing: -.02em; }
+    #summary { color: var(--muted); font-size: 12px; text-align: right; }
+    .filters {
+      display: grid;
+      grid-template-columns: minmax(200px, 1.5fr) repeat(3, minmax(145px, .7fr));
+      gap: 10px;
+      margin-bottom: 13px;
+    }
+    .filters input, .filters select {
+      width: 100%;
+      min-height: 42px;
+      border: 1px solid var(--rule);
+      border-radius: 0;
+      background: #fffdf9;
+      color: var(--ink);
+      padding: 9px 11px;
+    }
+    .filters input:focus, .filters select:focus, button:focus-visible, a:focus-visible {
+      outline: 3px solid #c5806d;
+      outline-offset: 2px;
+    }
+    .table-shell { overflow-x: auto; border: 1px solid var(--rule); background: #fffdf9; }
+    table { width: 100%; min-width: 1120px; border-collapse: collapse; font-size: 12px; }
+    th, td { padding: 11px 12px; border-bottom: 1px solid #e9e2d5; text-align: right; white-space: nowrap; }
+    th { background: var(--paper-deep); color: #47423c; font-size: 10px; letter-spacing: .08em; text-transform: uppercase; }
+    th:first-child, td:first-child, th:nth-child(2), td:nth-child(2), th:nth-child(3), td:nth-child(3) { text-align: left; }
+    tbody tr:last-child td { border-bottom: 0; }
+    tbody tr:hover td { background: #faf5eb; }
+    .sort-button { padding: 0; border: 0; background: none; color: inherit; font-size: inherit; font-weight: 700; letter-spacing: inherit; text-transform: inherit; cursor: pointer; }
+    .model-cell { min-width: 170px; }
+    .model-name { display: block; color: var(--ink); font-weight: 700; }
+    .model-id { display: block; max-width: 240px; overflow: hidden; color: var(--muted); font-family: ui-monospace, SFMono-Regular, Consolas, monospace; font-size: 10px; text-overflow: ellipsis; }
+    .source-tag, .coverage-tag { display: inline-block; border: 1px solid var(--rule); padding: 2px 6px; background: #fff; color: #514b43; font-size: 10px; }
+    .source-paper { border-color: #d6b6a7; background: var(--accent-soft); color: #71312a; }
+    .coverage-full { border-color: #b6cbbd; background: #edf4ef; color: var(--green); }
+    .score { font-variant-numeric: tabular-nums; }
+    .score-overall { color: var(--accent); font-weight: 800; }
+    .details-row td { padding: 0; text-align: left; white-space: normal; }
+    details { padding: 10px 12px; }
+    summary { color: var(--accent); cursor: pointer; font-size: 11px; font-weight: 700; }
+    .detail-content { display: grid; grid-template-columns: repeat(3, minmax(150px, 1fr)); gap: 12px; padding: 13px 0 4px; }
+    .detail-block h3 { margin: 0 0 5px; font-family: var(--sans); font-size: 10px; letter-spacing: .1em; text-transform: uppercase; }
+    .detail-block p { margin: 3px 0; color: #514b43; font-size: 11px; overflow-wrap: anywhere; }
+    .empty, .error { padding: 28px 16px; color: var(--muted); text-align: center; }
+    .error { color: #8a2422; }
+    .footnote { margin: 12px 0 40px; color: var(--muted); font-size: 11px; }
+    .contribute { margin: 42px 0 54px; padding: 26px; border-top: 2px solid var(--accent); background: var(--paper-deep); }
+    .contribute h2 { margin: 0 0 7px; font-size: 26px; }
+    .contribute p { max-width: 760px; margin: 0 0 15px; color: #4c4944; }
+    footer { border-top: 1px solid var(--rule); padding: 20px 0 28px; color: var(--muted); font-size: 11px; }
+    .sr-only { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0; }
+
+    @media (max-width: 760px) {
+      .page { width: min(100% - 24px, 1440px); }
+      .hero { padding: 38px 0 28px; }
+      .callout { grid-template-columns: 1fr; }
+      .button-link { justify-self: start; }
+      .filters { grid-template-columns: 1fr 1fr; }
+      .filters input { grid-column: 1 / -1; }
+      .section-heading { align-items: start; flex-direction: column; gap: 4px; }
+      #summary { text-align: left; }
+      .detail-content { grid-template-columns: 1fr 1fr; }
+    }
+    @media (max-width: 440px) {
+      .masthead { font-size: 10px; }
+      .intro { font-size: 17px; }
+      .filters { grid-template-columns: 1fr; }
+      .filters input { grid-column: auto; }
+      .detail-content { grid-template-columns: 1fr; }
+      .contribute { padding: 20px 16px; }
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <div class="page masthead">
+      <div class="brand">AVI<span>·</span>Bench</div>
+      <div>Audio-Visual Intelligence &nbsp;·&nbsp; Community Leaderboard</div>
+    </div>
+  </header>
+
+  <main class="page">
+    <section class="hero" aria-labelledby="page-title">
+      <p class="eyebrow">Community results</p>
+      <h1 id="page-title">AVI-Bench Leaderboard</h1>
+      <p class="intro">Compare audio-visual intelligence results across perception, understanding, reasoning, and primitive sensation. Every entry links to its reported source.</p>
+      <nav class="links" aria-label="Project links">
+        <a href="https://fudancvl.github.io/AVI-Bench/">Project page</a>
+        <a href="https://github.com/FudanCVL/AVI-Bench">Code</a>
+        <a href="https://huggingface.co/datasets/FudanCVL/AVIBench">Dataset</a>
+        <a href="https://arxiv.org/abs/2606.07643">Paper</a>
+      </nav>
+    </section>
+
+    <aside class="callout">
+      <p><strong>Contribute a result.</strong> Submit a pull request with the required model, benchmark, coverage, score, and source information. A maintainer reviews it before merge. A merged entry identifies its source; it does not imply an independent reproduction.</p>
+      <a class="button-link" href="https://huggingface.co/spaces/FudanCVL/AVI-Bench/tree/main">Submission guide</a>
+    </aside>
+
+    <section aria-labelledby="results-title">
+      <div class="section-heading">
+        <div>
+          <p class="eyebrow">Results</p>
+          <h2 id="results-title">Model comparison</h2>
+        </div>
+        <div id="summary" aria-live="polite">Loading results…</div>
+      </div>
+
+      <div class="filters" aria-label="Leaderboard filters">
+        <label class="sr-only" for="search">Search models</label>
+        <input id="search" type="search" placeholder="Search model, provider, or ID">
+        <label class="sr-only" for="benchmark-filter">Filter benchmark version</label>
+        <select id="benchmark-filter"><option value="all">All benchmark versions</option></select>
+        <label class="sr-only" for="provider-filter">Filter provider</label>
+        <select id="provider-filter"><option value="all">All providers</option></select>
+        <label class="sr-only" for="source-filter">Filter source</label>
+        <select id="source-filter"><option value="all">All sources</option></select>
+      </div>
+
+      <div class="table-shell">
+        <table aria-describedby="leaderboard-note">
+          <thead>
+            <tr>
+              <th><button class="sort-button" data-sort="rank" aria-label="Sort by rank">Rank</button></th>
+              <th><button class="sort-button" data-sort="model_name">Model</button></th>
+              <th><button class="sort-button" data-sort="source">Source</button></th>
+              <th><button class="sort-button" data-sort="benchmark_version">Benchmark</button></th>
+              <th><button class="sort-button" data-sort="coverage">Coverage</button></th>
+              <th><button class="sort-button" data-sort="overall" aria-sort="descending">Overall</button></th>
+              <th><button class="sort-button" data-sort="perception">Perception</button></th>
+              <th><button class="sort-button" data-sort="understanding">Understanding</button></th>
+              <th><button class="sort-button" data-sort="reasoning">Reasoning</button></th>
+              <th><button class="sort-button" data-sort="sensation">Sensation</button></th>
+              <th><button class="sort-button" data-sort="l1_task">L1</button></th>
+              <th><button class="sort-button" data-sort="l2_modality">L2</button></th>
+              <th><button class="sort-button" data-sort="l3_stage">L3</button></th>
+              <th><button class="sort-button" data-sort="l4_domain">L4</button></th>
+              <th><span class="sr-only">Details</span></th>
+            </tr>
+          </thead>
+          <tbody id="results-body">
+            <tr><td class="empty" colspan="15">Loading results…</td></tr>
+          </tbody>
+        </table>
+      </div>
+      <p id="leaderboard-note" class="footnote">Scores use percentage points (0–100). Full evaluations with an overall score are ranked within their benchmark version; partial evaluations and entries without an overall score remain visible without a rank. Source labels identify where a score was reported, not an official audit badge.</p>
+    </section>
+
+    <section class="contribute" aria-labelledby="contribute-title">
+      <p class="eyebrow">Open contribution</p>
+      <h2 id="contribute-title">Add a result by pull request</h2>
+      <p>Copy the result template, add one record to the results file, and open a PR in this Space repository. Include a public source link and keep the diff limited to score metadata. Do not submit benchmark samples, labels, raw model responses, or credentials.</p>
+      <a class="button-link" href="https://huggingface.co/spaces/FudanCVL/AVI-Bench/discussions">Open Space community</a>
+      <a class="button-link" href="https://huggingface.co/spaces/FudanCVL/AVI-Bench/tree/main">View files and guide</a>
+    </section>
+  </main>
+
+  <footer>
+    <div class="page">AVI-Bench &copy; 2026. Dataset use is governed by the <a href="https://github.com/FudanCVL/AVI-Bench/blob/main/DATA_USE_POLICY.md">AVI-Bench Data Use Policy</a>.</div>
+  </footer>
+
+  <script>
+    (function () {
+      "use strict";
+
+      var SOURCE_LABELS = {
+        paper: "Paper reported",
+        participant: "Participant submission",
+        maintainer: "Maintainer evaluation"
+      };
+      var entries = [];
+      var rankById = new Map();
+      var sortKey = "overall";
+      var sortDirection = -1;
+      var body = document.getElementById("results-body");
+      var summary = document.getElementById("summary");
+      var search = document.getElementById("search");
+      var benchmarkFilter = document.getElementById("benchmark-filter");
+      var providerFilter = document.getElementById("provider-filter");
+      var sourceFilter = document.getElementById("source-filter");
+
+      function text(value) {
+        return value === null || value === undefined || value === "" ? "—" : String(value);
+      }
+
+      function score(value) {
+        return typeof value === "number" && Number.isFinite(value) ? value.toFixed(2) : "—";
+      }
+
+      function compareText(left, right) {
+        return String(left || "").localeCompare(String(right || ""), undefined, { numeric: true, sensitivity: "base" });
+      }
+
+      function addOption(select, value, label) {
+        var option = document.createElement("option");
+        option.value = value;
+        option.textContent = label;
+        select.appendChild(option);
+      }
+
+      function populateFilters() {
+        Array.from(new Set(entries.map(function (entry) { return entry.benchmark_version; })))
+          .sort(compareText).forEach(function (value) { addOption(benchmarkFilter, value, value); });
+        Array.from(new Set(entries.map(function (entry) { return entry.provider; })))
+          .sort(compareText).forEach(function (value) { addOption(providerFilter, value, value); });
+        Array.from(new Set(entries.map(function (entry) { return entry.source.type; })))
+          .sort(compareText).forEach(function (value) { addOption(sourceFilter, value, SOURCE_LABELS[value] || value); });
+      }
+
+      function buildRanks() {
+        var groups = new Map();
+        entries.filter(function (entry) {
+          return entry.coverage.status === "full" && typeof entry.scores.overall === "number";
+        }).forEach(function (entry) {
+          var version = entry.benchmark_version;
+          if (!groups.has(version)) groups.set(version, []);
+          groups.get(version).push(entry);
+        });
+        groups.forEach(function (group) {
+          group.sort(function (a, b) { return b.scores.overall - a.scores.overall || compareText(a.model_name, b.model_name); });
+          group.forEach(function (entry, index) { rankById.set(entry.id, index + 1); });
+        });
+      }
+
+      function matches(entry) {
+        var query = search.value.trim().toLowerCase();
+        var haystack = [entry.model_name, entry.model_id, entry.provider].join(" ").toLowerCase();
+        return (!query || haystack.indexOf(query) !== -1)
+          && (benchmarkFilter.value === "all" || entry.benchmark_version === benchmarkFilter.value)
+          && (providerFilter.value === "all" || entry.provider === providerFilter.value)
+          && (sourceFilter.value === "all" || entry.source.type === sourceFilter.value);
+      }
+
+      function sortValue(entry, key) {
+        if (key === "rank") return rankById.has(entry.id) ? rankById.get(entry.id) : Infinity;
+        if (key === "model_name" || key === "benchmark_version" || key === "provider") return entry[key];
+        if (key === "source") return SOURCE_LABELS[entry.source.type] || entry.source.type;
+        if (key === "coverage") return entry.coverage.tasks_completed / entry.coverage.tasks_total;
+        if (key === "overall") return entry.scores.overall;
+        if (["perception", "understanding", "reasoning", "sensation"].indexOf(key) !== -1) return (entry.scores.stages || {})[key];
+        return (entry.scores.taxonomy || {})[key];
+      }
+
+      function compareEntries(a, b) {
+        if (sortKey !== "benchmark_version") {
+          var versionOrder = compareText(a.benchmark_version, b.benchmark_version);
+          if (versionOrder !== 0) return versionOrder;
+        }
+        var left = sortValue(a, sortKey);
+        var right = sortValue(b, sortKey);
+        if (sortKey === "rank" && (left === Infinity || right === Infinity)) {
+          if (left !== right) return left === Infinity ? 1 : -1;
+        }
+        if (left === null || left === undefined || right === null || right === undefined) {
+          if (left !== right) return left === null || left === undefined ? 1 : -1;
+        }
+        if (typeof left === "number" || typeof right === "number") {
+          left = typeof left === "number" ? left : -Infinity;
+          right = typeof right === "number" ? right : -Infinity;
+          if (left !== right) return (left - right) * sortDirection;
+        } else {
+          var textOrder = compareText(left, right);
+          if (textOrder !== 0) return textOrder * sortDirection;
+        }
+        return compareText(a.model_name, b.model_name);
+      }
+
+      function makeCell(value, className) {
+        var cell = document.createElement("td");
+        if (className) cell.className = className;
+        cell.textContent = value;
+        return cell;
+      }
+
+      function addDetailBlock(container, title, lines) {
+        var block = document.createElement("div");
+        block.className = "detail-block";
+        var heading = document.createElement("h3");
+        heading.textContent = title;
+        block.appendChild(heading);
+        lines.forEach(function (line) {
+          var paragraph = document.createElement("p");
+          paragraph.textContent = line;
+          block.appendChild(paragraph);
+        });
+        container.appendChild(block);
+      }
+
+      function detailRow(entry) {
+        var row = document.createElement("tr");
+        row.className = "details-row";
+        var cell = document.createElement("td");
+        cell.colSpan = 15;
+        var details = document.createElement("details");
+        var summaryLine = document.createElement("summary");
+        summaryLine.textContent = "Details and task scores";
+        details.appendChild(summaryLine);
+        var content = document.createElement("div");
+        content.className = "detail-content";
+
+        var coverage = entry.coverage;
+        var sampleCoverage = coverage.samples_total === null || coverage.samples_total === undefined
+          ? "Sample count not reported"
+          : text(coverage.samples_completed) + " / " + text(coverage.samples_total) + " samples";
+        var sourceType = SOURCE_LABELS[entry.source.type] || entry.source.type;
+        addDetailBlock(content, "Record", [
+          "Model ID: " + entry.model_id,
+          "Provider: " + entry.provider,
+          "Benchmark: " + entry.benchmark_version,
+          "Evaluation date: " + text(entry.evaluation_date),
+          "Source type: " + sourceType,
+          "Coverage: " + coverage.tasks_completed + " / " + coverage.tasks_total + " tasks; " + sampleCoverage
+        ]);
+        addDetailBlock(content, "Scores", [
+          "Overall: " + score(entry.scores.overall),
+          "Stages: " + Object.keys(entry.scores.stages || {}).map(function (key) {
+            return key + " " + score(entry.scores.stages[key]);
+          }).join(" · ") || "No stage scores reported",
+          "Taxonomy: " + Object.keys(entry.scores.taxonomy || {}).map(function (key) {
+            return key.toUpperCase() + " " + score(entry.scores.taxonomy[key]);
+          }).join(" · ") || "No taxonomy scores reported"
+        ]);
+        var sourceBlock = document.createElement("div");
+        sourceBlock.className = "detail-block";
+        var sourceHeading = document.createElement("h3");
+        sourceHeading.textContent = "Source and notes";
+        sourceBlock.appendChild(sourceHeading);
+        var sourceLink = document.createElement("a");
+        sourceLink.href = entry.source.url;
+        sourceLink.target = "_blank";
+        sourceLink.rel = "noopener noreferrer";
+        sourceLink.textContent = "Open source";
+        sourceBlock.appendChild(sourceLink);
+        if (entry.submitter) {
+          var submitter = document.createElement("p");
+          submitter.textContent = "Submitted by: " + entry.submitter;
+          sourceBlock.appendChild(submitter);
+        }
+        if (entry.notes) {
+          var notes = document.createElement("p");
+          notes.textContent = entry.notes;
+          sourceBlock.appendChild(notes);
+        }
+        content.appendChild(sourceBlock);
+
+        var taskScores = entry.scores.tasks || {};
+        var taskLines = Object.keys(taskScores).sort(compareText).map(function (task) {
+          var value = taskScores[task];
+          if (value && typeof value === "object") {
+            return task + ": " + Object.keys(value).sort(compareText).map(function (metric) {
+              return metric + " " + score(value[metric]);
+            }).join(" · ");
+          }
+          return task + ": " + score(value);
+        });
+        if (taskLines.length) addDetailBlock(content, "Task scores", taskLines);
+
+        details.appendChild(content);
+        cell.appendChild(details);
+        row.appendChild(cell);
+        return row;
+      }
+
+      function render() {
+        var visible = entries.filter(matches).sort(compareEntries);
+        body.replaceChildren();
+        if (!visible.length) {
+          var emptyRow = document.createElement("tr");
+          var emptyCell = document.createElement("td");
+          emptyCell.className = "empty";
+          emptyCell.colSpan = 15;
+          emptyCell.textContent = entries.length ? "No results match these filters." : "No merged results yet. Submit a result by pull request.";
+          emptyRow.appendChild(emptyCell);
+          body.appendChild(emptyRow);
+          summary.textContent = entries.length ? "0 matching records" : "No results published yet";
+          return;
+        }
+
+        visible.forEach(function (entry) {
+          var row = document.createElement("tr");
+          var rank = rankById.get(entry.id);
+          row.appendChild(makeCell(rank ? String(rank) : "—"));
+
+          var modelCell = document.createElement("td");
+          modelCell.className = "model-cell";
+          var modelName = document.createElement("span");
+          modelName.className = "model-name";
+          modelName.textContent = entry.model_name;
+          var modelId = document.createElement("span");
+          modelId.className = "model-id";
+          modelId.textContent = entry.model_id;
+          modelCell.appendChild(modelName);
+          modelCell.appendChild(modelId);
+          row.appendChild(modelCell);
+
+          var sourceCell = document.createElement("td");
+          var sourceTag = document.createElement("span");
+          sourceTag.className = "source-tag" + (entry.source.type === "paper" ? " source-paper" : "");
+          sourceTag.textContent = SOURCE_LABELS[entry.source.type] || entry.source.type;
+          sourceCell.appendChild(sourceTag);
+          row.appendChild(sourceCell);
+          row.appendChild(makeCell(entry.benchmark_version));
+
+          var coverageCell = document.createElement("td");
+          var coverageTag = document.createElement("span");
+          coverageTag.className = "coverage-tag" + (entry.coverage.status === "full" ? " coverage-full" : "");
+          coverageTag.textContent = entry.coverage.tasks_completed + "/" + entry.coverage.tasks_total + " tasks";
+          coverageCell.appendChild(coverageTag);
+          row.appendChild(coverageCell);
+
+          row.appendChild(makeCell(score(entry.scores.overall), "score score-overall"));
+          var stages = entry.scores.stages || {};
+          ["perception", "understanding", "reasoning", "sensation"].forEach(function (key) {
+            row.appendChild(makeCell(score(stages[key]), "score"));
+          });
+          var taxonomy = entry.scores.taxonomy || {};
+          ["l1_task", "l2_modality", "l3_stage", "l4_domain"].forEach(function (key) {
+            row.appendChild(makeCell(score(taxonomy[key]), "score"));
+          });
+          var detailCell = document.createElement("td");
+          var detailButton = document.createElement("button");
+          detailButton.className = "sort-button";
+          detailButton.type = "button";
+          detailButton.textContent = "View";
+          detailButton.setAttribute("aria-label", "View details for " + entry.model_name);
+          detailButton.addEventListener("click", function () {
+            var next = row.nextElementSibling;
+            if (next && next.classList.contains("details-row")) {
+              next.remove();
+            } else {
+              row.after(detailRow(entry));
+            }
+          });
+          detailCell.appendChild(detailButton);
+          row.appendChild(detailCell);
+          body.appendChild(row);
+        });
+        var ranked = visible.filter(function (entry) { return rankById.has(entry.id); }).length;
+        var unranked = visible.length - ranked;
+        summary.textContent = visible.length + " records · " + ranked + " ranked · " + unranked + " unranked";
+      }
+
+      document.querySelectorAll(".sort-button[data-sort]").forEach(function (button) {
+        button.addEventListener("click", function () {
+          var nextKey = button.getAttribute("data-sort");
+          if (sortKey === nextKey) sortDirection *= -1;
+          else {
+            sortKey = nextKey;
+            sortDirection = nextKey === "overall" || nextKey === "rank" ? -1 : 1;
+          }
+          document.querySelectorAll(".sort-button[data-sort]").forEach(function (item) {
+            item.removeAttribute("aria-sort");
+          });
+          button.setAttribute("aria-sort", sortDirection === -1 ? "descending" : "ascending");
+          render();
+        });
+      });
+      [search, benchmarkFilter, providerFilter, sourceFilter].forEach(function (control) {
+        control.addEventListener("input", render);
+        control.addEventListener("change", render);
+      });
+
+      fetch("./data/results.json", { cache: "no-store" })
+        .then(function (response) {
+          if (!response.ok) throw new Error("Could not load leaderboard data (HTTP " + response.status + ")");
+          return response.json();
+        })
+        .then(function (data) {
+          if (!data || data.schema_version !== 1 || !Array.isArray(data.entries)) {
+            throw new Error("Leaderboard data does not match the expected schema.");
+          }
+          entries = data.entries;
+          populateFilters();
+          buildRanks();
+          render();
+        })
+        .catch(function (error) {
+          body.replaceChildren();
+          var row = document.createElement("tr");
+          var cell = document.createElement("td");
+          cell.className = "error";
+          cell.colSpan = 15;
+          cell.textContent = error.message;
+          row.appendChild(cell);
+          body.appendChild(row);
+          summary.textContent = "Results could not be loaded";
+        });
+    })();
+  </script>
+</body>
 </html>

templates/result-entry.json

@@ -0,0 +1,37 @@
+{
+  "id": "replace-with-a-unique-slug",
+  "model_name": "Display name",
+  "provider": "Provider or research group",
+  "model_id": "Exact model identifier or paper name",
+  "benchmark_version": "Benchmark release identifier",
+  "source": {
+    "type": "paper",
+    "url": "https://doi.org/..."
+  },
+  "evaluation_date": null,
+  "coverage": {
+    "status": "full",
+    "tasks_completed": 14,
+    "tasks_total": 14,
+    "samples_completed": null,
+    "samples_total": null
+  },
+  "scores": {
+    "overall": null,
+    "stages": {
+      "perception": null,
+      "understanding": null,
+      "reasoning": null,
+      "sensation": null
+    },
+    "taxonomy": {
+      "l1_task": null,
+      "l2_modality": null,
+      "l3_stage": null,
+      "l4_domain": null
+    },
+    "tasks": {}
+  },
+  "submitter": "HF username",
+  "notes": "Optional concise context. Scores use percentage points from 0 to 100."
+}

validate_results.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""Validate the public AVI-Bench leaderboard data file."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import re
+import sys
+from datetime import date
+from pathlib import Path
+from urllib.parse import urlparse
+
+
+ROOT = Path(__file__).resolve().parent
+DEFAULT_DATA = ROOT / "data" / "results.json"
+SOURCE_TYPES = {"paper", "participant", "maintainer"}
+TOP_LEVEL_FIELDS = {
+    "id",
+    "model_name",
+    "provider",
+    "model_id",
+    "benchmark_version",
+    "source",
+    "evaluation_date",
+    "coverage",
+    "scores",
+    "submitter",
+    "notes",
+}
+
+
+class ValidationError(ValueError):
+    """Raised when leaderboard data fails its public schema checks."""
+
+
+def require_text(record: dict, field: str, path: str) -> str:
+    value = record.get(field)
+    if not isinstance(value, str) or not value.strip():
+        raise ValidationError(f"{path}.{field} must be a non-empty string")
+    return value.strip()
+
+
+def validate_score_values(value, path: str) -> None:
+    if value is None:
+        return
+    if isinstance(value, dict):
+        for key, child in value.items():
+            if not isinstance(key, str) or not key.strip():
+                raise ValidationError(f"{path} contains an empty metric name")
+            validate_score_values(child, f"{path}.{key}")
+        return
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        raise ValidationError(f"{path} must be a number or null")
+    if not math.isfinite(value) or not 0 <= value <= 100:
+        raise ValidationError(f"{path} must be between 0 and 100")
+
+
+def validate_entry(entry, index: int) -> str:
+    path = f"entries[{index}]"
+    if not isinstance(entry, dict):
+        raise ValidationError(f"{path} must be an object")
+
+    unknown = set(entry) - TOP_LEVEL_FIELDS
+    if unknown:
+        names = ", ".join(sorted(unknown))
+        raise ValidationError(f"{path} has unsupported fields: {names}")
+
+    record_id = require_text(entry, "id", path)
+    if not re.fullmatch(r"[a-zA-Z0-9][a-zA-Z0-9._-]{1,99}", record_id):
+        raise ValidationError(f"{path}.id must be a 2–100 character slug")
+
+    for field in ("model_name", "provider", "model_id", "benchmark_version"):
+        require_text(entry, field, path)
+
+    source = entry.get("source")
+    if not isinstance(source, dict):
+        raise ValidationError(f"{path}.source must be an object")
+    if set(source) != {"type", "url"}:
+        raise ValidationError(f"{path}.source must contain only type and url")
+    source_type = source.get("type")
+    if not isinstance(source_type, str) or source_type not in SOURCE_TYPES:
+        choices = ", ".join(sorted(SOURCE_TYPES))
+        raise ValidationError(f"{path}.source.type must be one of: {choices}")
+    source_url = require_text(source, "url", f"{path}.source")
+    parsed_url = urlparse(source_url)
+    if parsed_url.scheme != "https" or not parsed_url.netloc:
+        raise ValidationError(f"{path}.source.url must be an https URL")
+
+    evaluation_date = entry.get("evaluation_date")
+    if evaluation_date is not None:
+        if not isinstance(evaluation_date, str) or not re.fullmatch(
+            r"\d{4}-\d{2}-\d{2}", evaluation_date
+        ):
+            raise ValidationError(f"{path}.evaluation_date must be YYYY-MM-DD or null")
+        try:
+            date.fromisoformat(evaluation_date)
+        except ValueError as exc:
+            raise ValidationError(
+                f"{path}.evaluation_date must be YYYY-MM-DD or null"
+            ) from exc
+
+    coverage = entry.get("coverage")
+    if not isinstance(coverage, dict):
+        raise ValidationError(f"{path}.coverage must be an object")
+    allowed_coverage = {
+        "status", "tasks_completed", "tasks_total", "samples_completed", "samples_total"
+    }
+    if set(coverage) - allowed_coverage:
+        raise ValidationError(f"{path}.coverage has unsupported fields")
+    status = coverage.get("status")
+    if not isinstance(status, str) or status not in {"full", "partial"}:
+        raise ValidationError(f"{path}.coverage.status must be full or partial")
+    for field in ("tasks_completed", "tasks_total"):
+        count = coverage.get(field)
+        if isinstance(count, bool) or not isinstance(count, int) or count < 0:
+            raise ValidationError(f"{path}.coverage.{field} must be a non-negative integer")
+    tasks_completed = coverage["tasks_completed"]
+    tasks_total = coverage["tasks_total"]
+    if tasks_total == 0 or tasks_completed > tasks_total:
+        raise ValidationError(f"{path}.coverage task counts are inconsistent")
+    if status == "full" and tasks_completed != tasks_total:
+        raise ValidationError(f"{path} is full but does not cover every task")
+    for field in ("samples_completed", "samples_total"):
+        count = coverage.get(field)
+        if count is not None and (
+            isinstance(count, bool) or not isinstance(count, int) or count < 0
+        ):
+            raise ValidationError(
+                f"{path}.coverage.{field} must be a non-negative integer or null"
+            )
+    completed_samples = coverage.get("samples_completed")
+    total_samples = coverage.get("samples_total")
+    if (completed_samples is None) != (total_samples is None):
+        raise ValidationError(
+            f"{path}.coverage must report both sample counts or neither"
+        )
+    if completed_samples is not None and total_samples is not None:
+        if completed_samples > total_samples:
+            raise ValidationError(f"{path}.coverage sample counts are inconsistent")
+        if status == "full" and completed_samples != total_samples:
+            raise ValidationError(f"{path} is full but sample coverage is incomplete")
+    if status == "partial" and tasks_completed == tasks_total:
+        if completed_samples is None or completed_samples == total_samples:
+            raise ValidationError(f"{path} is partial but reports full coverage")
+
+    scores = entry.get("scores")
+    if not isinstance(scores, dict):
+        raise ValidationError(f"{path}.scores must be an object")
+    if set(scores) - {"overall", "stages", "taxonomy", "tasks"}:
+        raise ValidationError(f"{path}.scores has unsupported fields")
+    validate_score_values(scores, f"{path}.scores")
+
+    notes = entry.get("notes")
+    if notes is not None and (not isinstance(notes, str) or len(notes) > 1000):
+        raise ValidationError(f"{path}.notes must be text of at most 1000 characters")
+    submitter = entry.get("submitter")
+    if submitter is not None and not isinstance(submitter, str):
+        raise ValidationError(f"{path}.submitter must be text or null")
+    return record_id
+
+
+def validate_file(path: Path) -> int:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise ValidationError(f"cannot read {path}: {exc}") from exc
+    except json.JSONDecodeError as exc:
+        raise ValidationError(f"invalid JSON at line {exc.lineno}, column {exc.colno}") from exc
+
+    if not isinstance(data, dict) or set(data) != {"schema_version", "entries"}:
+        raise ValidationError("root must contain exactly schema_version and entries")
+    if type(data["schema_version"]) is not int or data["schema_version"] != 1:
+        raise ValidationError("schema_version must be 1")
+    entries = data["entries"]
+    if not isinstance(entries, list):
+        raise ValidationError("entries must be an array")
+
+    seen = set()
+    for index, entry in enumerate(entries):
+        record_id = validate_entry(entry, index)
+        if record_id in seen:
+            raise ValidationError(f"duplicate entry id: {record_id}")
+        seen.add(record_id)
+    return len(entries)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("path", nargs="?", type=Path, default=DEFAULT_DATA)
+    args = parser.parse_args()
+
+    try:
+        count = validate_file(args.path)
+    except ValidationError as exc:
+        print(f"Invalid leaderboard data: {exc}", file=sys.stderr)
+        return 1
+    print(f"Valid leaderboard data: {count} entr{'y' if count == 1 else 'ies'}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())