Publish compression benchmark results and interactive leaderboard

Publish the current 19-dataset result snapshot with separate C++, Java, and Python leaderboards, filters, dataset details, trade-off plots, and CSV export.

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,10 +1,40 @@
 ---
-title: CompressionBenchmark
-emoji: 🌖
-colorFrom: indigo
+title: Time Series Compression Benchmark
+emoji: 📊
+colorFrom: green
 colorTo: gray
 sdk: static
+app_file: index.html
 pinned: false
+short_description: Compression rates and encoding/decoding costs
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# THULab Time Series Compression Benchmark
+
+Interactive, static leaderboard of the existing `web_compression` project results, inspired by the grouped leaderboard interface of [GIFT-Eval](https://huggingface.co/spaces/Salesforce/GIFT-Eval).
+
+The Space serves published result snapshots. It does not execute compression experiments or accept raw dataset uploads. It has no runtime dependency on the project's Django server.
+
+## Update the results
+
+From the source project checkout, regenerate the snapshots with:
+
+```bash
+python3 deploy/huggingface-compressionbenchmark/export_results.py
+python3 deploy/huggingface-compressionbenchmark/build_ui_payload.py
+```
+
+Publish `README.md`, `index.html`, `style.css`, `app.js`, `data.json`, `ui-data.json`, `manifest.json`, `export_results.py`, and `build_ui_payload.py` to the static Space. The manifest records the exact source-file identities and metric boundaries. The compact browser payload retains the full snapshot's measurements and SHA-256 identity.
+
+Only measurements in the authoritative current project scope are exported. Missing metrics and missing coverage are displayed explicitly. Existing results do not imply independently verified round trips or uniform hardware environments unless those checks are recorded in the source.
+
+## Interface
+
+- Overall and per-dataset leaderboards with runtime, data-type, precision, family, and method filters
+- Sortable metrics, optional columns, and CSV download of the selected ranking
+- Compression rate versus encoding/decoding cost plots
+- Dataset-level method details, snapshot provenance, and metric definitions
+
+The default family view selects the best measured compression-rate configuration independently for each dataset. Switch to **Exact configuration** to hold a configuration fixed. Runtime results stay separate. The paper snapshot tab preserves the frozen source table and is separate from the current report aggregation.
+
+Source project: https://github.com/xjz17/web_compression

app.js

@@ -0,0 +1,161 @@
+const $ = (id) => document.getElementById(id);
+const escape = (value) => String(value ?? '').replace(/[&<>"']/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+const number = (v) => v != null && Number.isFinite(Number(v)) ? Number(v) : null;
+const mean = (values) => { const a = values.map(number).filter((n) => n !== null); return a.length ? a.reduce((s,n) => s+n,0)/a.length : null; };
+const fmt = (v, digits=3) => number(v) === null ? 'Not reported' : Number(v).toLocaleString('en-US',{maximumFractionDigits:digits,minimumFractionDigits:digits});
+const countFmt = (v) => Number(v).toLocaleString('en-US');
+const runtimeName = (v) => ({cpp:'C++',java:'Java',python:'Python'}[v] || v);
+const cols = [
+  {key:'compression_rate',label:'Average rate ↓',digits:4,visible:true},
+  {key:'overall_rate',label:'Overall rate ↓',digits:4,visible:false},
+  {key:'compression_time',label:'Encode ns/point ↓',digits:2,visible:true},
+  {key:'decompression_time',label:'Decode ns/point ↓',digits:2,visible:true},
+  {key:'compressed_bytes',label:'Compressed bytes',digits:0,visible:false},
+  {key:'original_bytes',label:'Original bytes',digits:0,visible:false},
+];
+let snapshot, records=[], methods=new Map(), datasets=new Map(), currentRows=[], activeTab='overall';
+let sort={key:'compression_rate',direction:1};
+let selectedMethod=null;
+const state = () => ({runtime:$('runtime').value,dataset:$('dataset').value,dtype:$('dtype').value,precision:$('precision').value,family:$('family').value,mode:$('row-mode').value,search:$('search').value.trim().toLowerCase(),complete:$('complete-only').checked});
+function scopeKey() { const s=state(); return s.dtype==='overall'?'overall':s.dtype==='int'?'integer':s.precision==='fixed'?'fixed_float':s.precision==='non_fixed'?'nonfixed_float':'float'; }
+function normalizeRecord(r) {
+  return { ...r,configuration:r.algorithm_variant??r.algorithm??r.method,method:r.algorithm_variant??r.algorithm??r.method,runtime:r.runtime ?? r.implementation_language ?? snapshot.benchmark?.implementation_language ?? 'cpp',
+    family:r.family ?? r.method_family ?? r.method ?? methods.get(r.algorithm)?.family ?? r.algorithm,
+    compression_rate:number(r.compression_rate ?? r.average_compression_rate),compression_time:number(r.compression_time_ns_per_point ?? r.compression_time),decompression_time:number(r.decompression_time_ns_per_point ?? r.decompression_time),
+    original_bytes:number(r.original_size_bytes ?? r.original_bytes ?? r.originalSize),compressed_bytes:number(r.compressed_size_bytes ?? r.compressed_bytes ?? r.compressedSize) };
+}
+function filteredRecords(ignoreMethod=false) {
+  const s=state(), scope=scopeKey();
+  let result=records.filter((r) => r.runtime===s.runtime && r.scope===scope && (s.dataset==='all'||r.dataset===s.dataset));
+  if(s.mode==='family') {
+    const best=new Map();
+    for(const r of result){const key=`${r.dataset}\0${r.family}`;const prev=best.get(key);if(!prev||r.compression_rate<prev.compression_rate||(r.compression_rate===prev.compression_rate&&r.configuration.localeCompare(prev.configuration)<0))best.set(key,r);}
+    result=[...best.values()].map(r=>({...r,method:r.family}));
+  }
+  return ignoreMethod?result:result.filter(r=>(s.family==='all'||r.family===s.family)&&(!s.search||(s.mode==='family'?r.family:`${r.method} ${r.family}`).toLowerCase().includes(s.search)));
+}
+function aggregate(input) {
+  const groups=new Map();
+  for(const r of input) { if(!groups.has(r.method)) groups.set(r.method,[]); groups.get(r.method).push(r); }
+  const totalDatasets=new Set(filteredRecords(true).map(r=>r.dataset)).size;
+  const rows=[];
+  for(const [method,source] of groups) {
+    const hasBytes=source.every(r=>r.original_bytes!==null && r.original_bytes>0 && r.compressed_bytes!==null && r.compressed_bytes>0);
+    const original=hasBytes?source.reduce((s,r)=>s+r.original_bytes,0):null, compressed=hasBytes?source.reduce((s,r)=>s+r.compressed_bytes,0):null;
+    rows.push({method,family:source[0].family,runtime:source[0].runtime,compression_rate:mean(source.map(r=>r.compression_rate)),compression_time:mean(source.map(r=>r.compression_time)),decompression_time:mean(source.map(r=>r.decompression_time)),overall_rate:hasBytes?compressed/original:null,original_bytes:original,compressed_bytes:compressed,coverage:new Set(source.map(r=>r.dataset)).size,totalDatasets,source});
+  }
+  return rows.filter(r=>!state().complete||r.coverage===totalDatasets).sort((a,b)=>{
+    const av=number(a[sort.key]),bv=number(b[sort.key]);
+    if(av===null&&bv===null)return a.method.localeCompare(b.method);
+    if(av===null)return 1;if(bv===null)return -1;
+    return sort.direction*(av-bv)||a.method.localeCompare(b.method);
+  });
+}
+function renderTable() {
+  const visible=cols.filter(c=>c.visible);
+  $('leaderboard').querySelector('thead').innerHTML=`<tr><th>Position</th><th>Method / configuration</th>${visible.map(c=>`<th aria-sort="${sort.key===c.key?(sort.direction===1?'ascending':'descending'):'none'}"><button data-sort="${c.key}" title="Sort ${escape(c.label)}">${escape(c.label)}${sort.key===c.key?(sort.direction===1?' ▴':' ▾'):''}</button></th>`).join('')}<th>Dataset coverage</th></tr>`;
+  const minima=Object.fromEntries(visible.map(c=>[c.key,Math.min(...currentRows.map(r=>number(r[c.key])).filter(n=>n!==null))]));
+  $('leaderboard').querySelector('tbody').innerHTML=currentRows.length?currentRows.map((r,i)=>`<tr><td class="rank numeric">${i+1}</td><td><button class="method-button" data-method="${escape(r.method)}">${escape(r.method)}</button><span class="method-family">${escape(r.family)} · ${escape(runtimeName(r.runtime))}</span></td>${visible.map(c=>`<td class="numeric ${!c.key.endsWith('bytes')&&number(r[c.key])!==null&&r[c.key]===minima[c.key]?'best':''}">${fmt(r[c.key],c.digits)}</td>`).join('')}<td><span class="coverage ${r.coverage===r.totalDatasets?'full':''}">${r.coverage} / ${r.totalDatasets}</span></td></tr>`).join(''):`<tr><td colspan="${visible.length+3}" class="empty-cell">No measurements match this selection. Try another runtime, data type, or dataset.</td></tr>`;
+  for(const button of $('leaderboard').querySelectorAll('[data-sort]'))button.addEventListener('click',()=>{const key=button.dataset.sort;sort={key,direction:sort.key===key?-sort.direction:1};refresh();});
+  for(const button of $('leaderboard').querySelectorAll('[data-method]'))button.addEventListener('click',()=>showMethod(button.dataset.method,true));
+  $('row-count').textContent=`${currentRows.length} ${state().mode==='family'?'method families':'method configurations'} · sorted by ${cols.find(c=>c.key===sort.key)?.label??sort.key}`;
+  $('download').disabled=!currentRows.length;
+}
+function refresh() {
+  if(!snapshot)return;
+  $('precision').disabled=$('dtype').value!=='float';
+  if(scopeKey()==='float'&&!records.some(r=>r.scope==='float')) {
+    // The exporter must publish an explicit all-float scope; never combine
+    // preaggregated fixed/non-fixed metrics and call it an all-float result.
+    $('results-note').textContent='All-float measurements are not available in this snapshot. Select a precision category.';
+  } else $('results-note').textContent=state().mode==='family'?'Each family uses its lowest-rate measured configuration per dataset. Configurations may differ across datasets; use Exact configuration for fixed parameters.':'Each row retains one exact configuration. Lower compression rates and lower ns/point are better. Coverage counts datasets, not identical column sets.';
+  currentRows=aggregate(filteredRecords());
+  const s=state(),scope=scopeKey(),ds=s.dataset==='all'?'all measured datasets':s.dataset;
+  const names={overall:'all numeric columns',integer:'integer columns',float:'floating-point columns',fixed_float:'fixed-precision float columns',nonfixed_float:'non-fixed-precision float columns'};
+  $('selection-summary').textContent=`${runtimeName(s.runtime)} · ${names[scope]||scope} · ${ds} · ${currentRows.length} methods`;
+  $('view-title').textContent=activeTab==='dataset'?`${s.dataset==='all'?'Dataset':s.dataset} leaderboard`:activeTab==='tradeoffs'?'Storage and execution trade-offs':'Overall leaderboard';
+  renderTable();
+  if(activeTab==='tradeoffs')renderChart();
+  if(selectedMethod)showMethod(selectedMethod,false);
+}
+function setTab(tab) {
+  activeTab=['overall','dataset','tradeoffs','methods','paper','about'].includes(tab)?tab:'overall';
+  for(const b of document.querySelectorAll('[data-tab]')){b.classList.toggle('active',b.dataset.tab===activeTab);if(b.dataset.tab===activeTab)b.setAttribute('aria-current','page');else b.removeAttribute('aria-current');}
+  $('results-view').hidden=['methods','paper','about'].includes(activeTab);$('methods-view').hidden=activeTab!=='methods';$('paper-view').hidden=activeTab!=='paper';$('about-view').hidden=activeTab!=='about';$('chart-view').hidden=activeTab!=='tradeoffs';
+  if(activeTab==='dataset'&&$('dataset').value==='all'){const first=[...datasets.keys()].find(k=>records.some(r=>r.dataset===k&&r.runtime===$('runtime').value));if(first)$('dataset').value=first;}
+  if(activeTab==='overall')$('dataset').value='all';
+  refresh();
+}
+function showMethod(method,focus=false) {
+  const row=currentRows.find(r=>r.method===method), detail=$('method-detail');
+  if(!row){selectedMethod=null;detail.hidden=true;return;}selectedMethod=method;
+  const meta=methods.get(method)??methods.get(row.source[0].configuration), pipeline=meta?.operator_pipeline;
+  const source=row.source.slice().sort((a,b)=>a.dataset.localeCompare(b.dataset));
+  detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${fmt(row.compression_time,2)}</strong><span>encoding ns/point</span></div><div><strong>${fmt(row.decompression_time,2)}</strong><span>decoding ns/point</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${pipeline?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}<p class="muted">Dataset metrics below come from the published result files. Independent round-trip evidence and hardware are ${snapshot.benchmark?.roundtrip_evidence?'documented in the manifest':'not reported for this snapshot'}.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Rate ↓</th><th>Encode ns/point ↓</th><th>Decode ns/point ↓</th><th>Original bytes</th><th>Compressed bytes</th></tr></thead><tbody>${source.map(r=>`<tr><td>${escape(r.dataset)}</td><td>${escape(r.configuration)}</td><td class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${fmt(r.compression_time,2)}</td><td class="numeric">${fmt(r.decompression_time,2)}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td></tr>`).join('')}</tbody></table></div>`;
+  detail.hidden=false;$('close-detail').addEventListener('click',()=>{detail.hidden=true;selectedMethod=null;});
+  if(focus){detail.scrollIntoView({block:'nearest',behavior:'auto'});detail.focus({preventScroll:true});}
+}
+function renderChart() {
+  const metric=$('chart-metric').value;
+  const valid=currentRows.filter(r=>r.compression_rate>0&&r[metric]>0);
+  if(!valid.length){$('chart').innerHTML='<p class="chart-empty muted">No positive measurements to plot for this selection.</p>';return;}
+  const width=1100,height=410,pad={left:85,right:35,top:30,bottom:65};
+  const maxRate=Math.max(...valid.map(r=>r.compression_rate))*1.08;
+  const logs=valid.map(r=>Math.log10(r[metric]));let minLog=Math.floor(Math.min(...logs)),maxLog=Math.ceil(Math.max(...logs));if(maxLog===minLog)maxLog=minLog+1;
+  const x=r=>pad.left+r/maxRate*(width-pad.left-pad.right),y=n=>height-pad.bottom-(Math.log10(n)-minLog)/(maxLog-minLog)*(height-pad.top-pad.bottom);
+  let graph='';
+  for(let i=0;i<=5;i++){const rate=maxRate*i/5,px=x(rate);graph+=`<line class="gridline" x1="${px}" y1="${pad.top}" x2="${px}" y2="${height-pad.bottom}"/><text class="axis-label" x="${px}" y="${height-pad.bottom+25}" text-anchor="middle">${fmt(rate,2)}</text>`;}
+  for(let i=minLog;i<=maxLog;i++){const n=10**i,py=y(n);graph+=`<line class="gridline" x1="${pad.left}" y1="${py}" x2="${width-pad.right}" y2="${py}"/><text class="axis-label" x="${pad.left-12}" y="${py+4}" text-anchor="end">${n.toLocaleString('en-US',{maximumFractionDigits:3})}</text>`;}
+  for(const r of valid)graph+=`<circle class="point" tabindex="0" role="button" aria-label="${escape(r.method)}: compression rate ${fmt(r.compression_rate,4)}, ${metric==='compression_time'?'encoding':'decoding'} ${fmt(r[metric],2)} ns per point" data-method="${escape(r.method)}" cx="${x(r.compression_rate)}" cy="${y(r[metric])}" r="6"><title>${escape(r.method)} | rate ${fmt(r.compression_rate,4)} | ${fmt(r[metric],2)} ns/point | coverage ${r.coverage}/${r.totalDatasets}</title></circle>`;
+  graph+=`<text class="axis-label" x="${width/2}" y="${height-13}" text-anchor="middle">Average compression rate (compressed / original) ↓</text><text class="axis-label" transform="translate(20 ${height/2}) rotate(-90)" text-anchor="middle">${metric==='compression_time'?'Encoding':'Decoding'} ns/point (log scale) ↓</text>`;
+  $('chart').innerHTML=`<svg viewBox="0 0 ${width} ${height}" role="img" aria-label="Measured compression rates versus ${metric==='compression_time'?'encoding':'decoding'} cost">${graph}</svg>`;
+  for(const p of $('chart').querySelectorAll('[data-method]')){p.addEventListener('click',()=>showMethod(p.dataset.method,true));p.addEventListener('keydown',e=>{if(e.key==='Enter'||e.key===' '){e.preventDefault();showMethod(p.dataset.method,true);}});}
+}
+function csv() {
+  const quote=v=>{let text=String(v??'');if(typeof v==='string'&&/^[=+@-]/.test(text))text="'"+text;return `"${text.replace(/"/g,'""')}"`;};
+  const columns=['position','method','runtime','scope','row_mode','selected_dataset','sort_metric','sort_direction','average_compression_rate','overall_compression_rate','encode_ns_per_point','decode_ns_per_point','dataset_coverage','datasets_in_scope','selected_configuration_by_dataset'];
+  const body=currentRows.map((r,i)=>[i+1,r.method,r.runtime,scopeKey(),state().mode,state().dataset,sort.key,sort.direction===1?'ascending':'descending',r.compression_rate,r.overall_rate,r.compression_time,r.decompression_time,r.coverage,r.totalDatasets,JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.configuration])))].map(quote).join(','));
+  const url=URL.createObjectURL(new Blob(['\ufeff'+[columns.join(','),...body].join('\r\n')],{type:'text/csv;charset=utf-8'}));const a=document.createElement('a');a.href=url;a.download=`THULab-compression-${state().runtime}-${scopeKey()}-${state().dataset}.csv`;a.click();setTimeout(()=>URL.revokeObjectURL(url),1000);
+}
+function renderAbout() {
+  const b=snapshot.benchmark||{},s=snapshot.source||{},c=snapshot.coverage||{};
+  const notes=[b.scope_note,b.aggregation_note,b.selection_note,...(b.notes||[]),...(b.measurement_boundaries||[])].filter(Boolean);
+  $('methodology').innerHTML=notes.map(n=>`<p class="notice">${escape(n)}</p>`).join('');
+  const definitions=b.metric_definitions||{};if(Object.keys(definitions).length)$('methodology').innerHTML+=`<dl class="definitions">${Object.entries(definitions).map(([k,v])=>`<div><dt>${escape(k.replaceAll('_',' '))}</dt><dd>${escape(typeof v==='string'?v:JSON.stringify(v))}</dd></div>`).join('')}</dl>`;
+  const exclusions=c.exclusions||c.excluded_datasets||snapshot.exclusions||[];
+  const info={ 'Snapshot exported':snapshot.exported_at||s.exported_at||'Not reported','Dataset scope generated':s.generated_at||'Not reported', 'Source checkout':s.git_commit||'Not reported','Source files':`${s.source_files?.length??0} metadata inputs and ${s.result_csv_files_used?.length??0} result CSVs (hashes in manifest)`,'Result entries across scopes':`${records.length} (scope slices can reuse a measurement)`,'Worktree source state':s.worktree_dirty_inputs?.length?'Includes current local changes; input file hashes identify the published snapshot.':'See manifest for source file hashes.','Runtime environment':b.hardware||'Hardware details are not recorded in this exported result snapshot.','Lossless evidence':b.roundtrip_evidence||'Lossless-design method filter from the source project; per-run round-trip verification is not recorded here.'};
+  $('provenance').innerHTML=`<table class="provenance-table"><tbody>${Object.entries(info).map(([k,v])=>`<tr><th>${escape(k)}</th><td class="source-code">${escape(v)}</td></tr>`).join('')}</tbody></table>${exclusions.length?`<h3>Excluded or unavailable results</h3><p class="source-code">${escape(typeof exclusions==='string'?exclusions:JSON.stringify(exclusions))}</p>`:''}`;
+  const groups=new Map();for(const r of records){if(!groups.has(r.family))groups.set(r.family,[]);groups.get(r.family).push(r.configuration);}
+  $('method-catalog').innerHTML=`<div class="method-groups">${[...groups].sort((a,b)=>a[0].localeCompare(b[0])).map(([family,names])=>`<section class="method-group"><h3>${escape(family)}</h3><ul>${[...new Set(names)].sort().map(n=>`<li>${escape(n)}</li>`).join('')}</ul></section>`).join('')}</div>`;
+}
+function init() {
+  if(snapshot.compact_records){const t=snapshot.record_tables;snapshot.dataset_results=snapshot.compact_records.map(r=>({dataset:t.datasets[r[0]],scope:t.scopes[r[1]],runtime:t.runtimes[r[2]],family:t.families[r[3]],method:t.configurations[r[4]],algorithm_variant:t.configurations[r[4]],compression_rate:r[5],compression_time_ns_per_point:r[6],decompression_time_ns_per_point:r[7],original_size_bytes:r[8],compressed_size_bytes:r[9]}));delete snapshot.compact_records;}
+  for(const m of snapshot.methods||[]) { const method=typeof m==='string'?{name:m}:m;methods.set(method.name??method.method,method);for(const c of method.configurations||[])methods.set(c.algorithm_variant,{...method,name:c.algorithm_variant,family:method.name}); }
+  for(const d of snapshot.datasets||[])datasets.set(d.key??d.dataset,d);
+  records=(snapshot.dataset_results||snapshot.records||[]).map(normalizeRecord).filter(r=>r.method&&r.dataset&&r.compression_rate>0);
+  for(const r of records)if(!methods.has(r.method))methods.set(r.method,{name:r.method,family:r.family});
+  const runtimes=[...new Set(records.map(r=>r.runtime))].sort((a,b)=>['cpp','java','python'].indexOf(a)-['cpp','java','python'].indexOf(b));
+  $('runtime').innerHTML=runtimes.map(r=>`<option value="${escape(r)}">${escape(runtimeName(r))}</option>`).join('');
+  $('dataset').innerHTML='<option value="all">All measured datasets</option>'+[...datasets.values()].sort((a,b)=>(a.key??a.dataset).localeCompare(b.key??b.dataset)).map(d=>`<option value="${escape(d.key??d.dataset)}">${escape(d.key??d.dataset)}</option>`).join('');
+  $('family').innerHTML='<option value="all">All method families</option>'+[...new Set(records.map(r=>r.family))].sort().map(f=>`<option value="${escape(f)}">${escape(f)}</option>`).join('');
+  $('dataset-count').textContent=countFmt(new Set(records.map(r=>r.dataset)).size);$('method-count').textContent=countFmt(new Set(records.map(r=>r.family)).size);$('runtime-count').textContent=runtimes.length;$('record-count').textContent=countFmt(snapshot.coverage?.runtime_configuration_count??new Set(records.map(r=>`${r.runtime}\0${r.method}`)).size);
+  const exported=snapshot.exported_at||snapshot.source?.exported_at||'not reported';$('snapshot').textContent=`Result snapshot exported · ${String(exported).replace('T',' ').slice(0,19)}${exported==='not reported'?'':' UTC'}`;$('footer-snapshot').textContent=`Source inputs documented in the manifest`;
+  $('column-options').innerHTML=cols.map(c=>`<label><input type="checkbox" data-column="${c.key}" ${c.visible?'checked':''}>${escape(c.label)}</label>`).join('');
+  for(const input of $('column-options').querySelectorAll('input'))input.addEventListener('change',()=>{cols.find(c=>c.key===input.dataset.column).visible=input.checked;renderTable();});
+  for(const id of ['runtime','dtype','precision','dataset','family','row-mode','complete-only'])$(id).addEventListener('change',refresh);$('search').addEventListener('input',refresh);$('chart-metric').addEventListener('change',renderChart);$('download').addEventListener('click',csv);
+  $('reset').addEventListener('click',()=>{$('runtime').value=runtimes.includes('cpp')?'cpp':runtimes[0];$('dtype').value='overall';$('precision').value='all';$('dataset').value='all';$('row-mode').value='family';$('search').value='';$('family').value='all';$('complete-only').checked=false;selectedMethod=null;$('method-detail').hidden=true;sort={key:'compression_rate',direction:1};setTab(activeTab);});
+  for(const tab of document.querySelectorAll('[data-tab]'))tab.addEventListener('click',()=>{history.replaceState(null,'',`#${tab.dataset.tab}`);setTab(tab.dataset.tab);});
+  const renderPaper=()=>{const rows=(snapshot.paper_table3?.rows||[]).filter(r=>r.scope===$('paper-scope').value);$('paper-table').querySelector('tbody').innerHTML=rows.map(r=>`<tr><td>${escape(r.method)}</td><td class="numeric">${fmt(r.rank,1)}</td><td class="numeric">${fmt(r.average_compression_rate,4)}</td><td class="numeric">${fmt(r.average_compression_time_ns_per_point,1)}</td><td class="numeric">${fmt(r.average_decompression_time_ns_per_point,1)}</td><td class="numeric">${fmt(r.median_balanced_score,4)}</td></tr>`).join('');};$('paper-scope').addEventListener('change',renderPaper);renderPaper();
+  renderAbout();setTab(location.hash.slice(1)||'overall');
+  document.documentElement.dataset.ready='true';
+}
+function setupTheme() {
+  let stored;try{stored=localStorage.getItem('thulab-theme');}catch{}
+  const query=new URLSearchParams(location.search).get('__theme');
+  const theme=stored||(['dark','light'].includes(query)?query:matchMedia('(prefers-color-scheme:dark)').matches?'dark':'light');
+  document.documentElement.dataset.theme=theme;$('theme').textContent=theme==='dark'?'Light mode':'Dark mode';
+  $('theme').addEventListener('click',()=>{const next=document.documentElement.dataset.theme==='dark'?'light':'dark';document.documentElement.dataset.theme=next;$('theme').textContent=next==='dark'?'Light mode':'Dark mode';try{localStorage.setItem('thulab-theme',next);}catch{}});
+}
+setupTheme();
+try { const response=await fetch('./ui-data.json');if(!response.ok)throw new Error(`Snapshot request returned ${response.status}`);snapshot=await response.json();init(); }
+catch(e){$('load-error').hidden=false;$('load-error').textContent=`The result snapshot could not be loaded. Please reload the page or download the JSON from the repository. ${e.message}`;$('snapshot').textContent='Snapshot unavailable';$('leaderboard').querySelector('tbody').innerHTML='<tr><td class="empty-cell">Results unavailable.</td></tr>';}

build_ui_payload.py

@@ -0,0 +1,36 @@
+"""Build a compact UI payload from the independently hashed full result snapshot."""
+from __future__ import annotations
+import datetime
+import hashlib
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+
+def build() -> None:
+    source = ROOT / 'data.json'
+    data = json.loads(source.read_text())
+    rows = data['dataset_results']
+    fields = {'datasets': 'dataset', 'scopes': 'scope', 'runtimes': 'runtime',
+              'families': 'family', 'configurations': 'algorithm_variant'}
+    tables = {key: sorted({r[field] for r in rows}) for key, field in fields.items()}
+    indices = {key: {v:i for i,v in enumerate(values)} for key,values in tables.items()}
+    compact = []
+    for r in rows:
+        compact.append([*(indices[key][r[field]] for key,field in fields.items()),
+                        r['compression_rate'], r['compression_time_ns_per_point'],
+                        r['decompression_time_ns_per_point'], r['original_size_bytes'],
+                        r['compressed_size_bytes']])
+    payload = {key: data[key] for key in ('schema_version','benchmark','coverage','datasets','methods','scopes','source','paper_table3')}
+    payload['exported_at'] = datetime.datetime.now(datetime.timezone.utc).isoformat()
+    payload['source_data_sha256'] = hashlib.sha256(source.read_bytes()).hexdigest()
+    payload['record_tables'] = tables
+    payload['compact_records'] = compact
+    output = ROOT / 'ui-data.json'
+    output.write_text(json.dumps(payload, ensure_ascii=False, separators=(',', ':'), allow_nan=False)+'\n')
+    print(json.dumps({'file':output.name,'records':len(rows),'bytes':output.stat().st_size,
+                      'source_data_sha256':payload['source_data_sha256'],
+                      'ui_sha256':hashlib.sha256(output.read_bytes()).hexdigest()}))
+
+if __name__ == '__main__':
+    build()

data.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5230a0518ec3939048f0ce5731c2a29a661e98e3f493709c92fb260871b5e1c
+size 28047985

export_results.py

@@ -0,0 +1,582 @@
+#!/usr/bin/env python3
+"""Export a self-contained, public compression benchmark snapshot for HF Spaces.
+
+The exporter reads the existing benchmark result CSVs through the same parsing,
+sanitization, family-label, and float-precision helpers used by the Django app.
+It writes only aggregate measurements and public dataset metadata; raw datasets,
+uploaded user data, credentials, logs, and executable artifacts are excluded.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+import subprocess
+import sys
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+
+EXPORT_DIR = Path(__file__).resolve().parent
+REPO_ROOT = EXPORT_DIR.parents[1]
+BACKEND_DIR = REPO_ROOT / "backend"
+
+SOURCE_PATHS = {
+    "paper_table3": REPO_ROOT / "backend/myapp/paper_table3_snapshot.json",
+    "dataset_scope": REPO_ROOT / "benchmark/reference/datasets/ledger_public_compress_summary.json",
+    "dataset_catalog": REPO_ROOT / "backend/dataset_result/catalog_public_items.json",
+    "method_pipelines": REPO_ROOT / "benchmark/reference/methods/method_operator_pipelines.json",
+}
+
+SCOPES = (
+    {"key": "integer", "label": "Integer", "data_type": "int", "float_precision": "all"},
+    {"key": "float", "label": "All float", "data_type": "float", "float_precision": "all"},
+    {"key": "fixed_float", "label": "Fixed-precision float", "data_type": "float", "float_precision": "fixed"},
+    {"key": "nonfixed_float", "label": "Non-fixed-precision float", "data_type": "float", "float_precision": "non_fixed"},
+    {"key": "overall", "label": "All numeric", "data_type": "overall", "float_precision": "all"},
+)
+
+RUNTIMES = ("cpp", "java", "python")
+
+
+def _read_json(path: Path) -> Any:
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def _git(*args: str) -> str:
+    completed = subprocess.run(
+        ["git", *args],
+        cwd=REPO_ROOT,
+        check=True,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    return completed.stdout.strip()
+
+
+def _finite(value: Any, *, positive: bool = False) -> float:
+    number = float(value)
+    if not math.isfinite(number) or (positive and number <= 0):
+        raise ValueError(f"Invalid numeric value: {value!r}")
+    return number
+
+
+@lru_cache(maxsize=None)
+def _algorithm_metadata(algorithm_key: str) -> tuple[bool, str | None, bool]:
+    from myapp.home_leaderboard_boxplot_data import (
+        boxplot_group_label,
+        is_home_leaderboard_algorithm_enabled,
+        is_lossy_boxplot_label,
+    )
+
+    family = boxplot_group_label(algorithm_key)
+    return (
+        is_home_leaderboard_algorithm_enabled(algorithm_key),
+        family,
+        is_lossy_boxplot_label(family or ""),
+    )
+
+
+def _public_datasets(catalog_payload: dict[str, Any], dataset_keys: list[str]) -> list[dict[str, Any]]:
+    by_key = {str(item["key"]): item for item in catalog_payload.get("items", [])}
+    if set(by_key) != set(dataset_keys):
+        raise RuntimeError(
+            "Dataset catalog and frozen 19-dataset scope differ: "
+            f"catalog_only={sorted(set(by_key) - set(dataset_keys))}, "
+            f"scope_only={sorted(set(dataset_keys) - set(by_key))}"
+        )
+    fields = (
+        "key",
+        "category",
+        "row_count",
+        "column_count",
+        "numeric_column_count",
+        "size_bytes",
+        "prebuilt_tsfile_size_bytes",
+        "source",
+        "source_url",
+    )
+    return [{field: by_key[key].get(field) for field in fields} for key in dataset_keys]
+
+
+def _paper_rows(snapshot: dict[str, Any]) -> tuple[list[str], list[dict[str, Any]]]:
+    scope_keys = [str(value) for value in snapshot.get("scopes", [])]
+    expected_scope_keys = ["integer", "fixed_float", "nonfixed_float", "overall"]
+    if scope_keys != expected_scope_keys:
+        raise RuntimeError(f"Unexpected paper snapshot scopes: {scope_keys}")
+
+    methods: list[str] = []
+    rows: list[dict[str, Any]] = []
+    metric_fields = (
+        ("rank", "rank"),
+        ("average_rate", "average_compression_rate"),
+        ("average_compression_ns", "average_compression_time_ns_per_point"),
+        ("average_decompression_ns", "average_decompression_time_ns_per_point"),
+        ("median_balance_score", "median_balanced_score"),
+    )
+    for source_row in snapshot.get("rows", []):
+        method = str(source_row["method"])
+        methods.append(method)
+        for scope_index, scope_key in enumerate(scope_keys):
+            row: dict[str, Any] = {"scope": scope_key, "method": method}
+            for source_field, output_field in metric_fields:
+                values = source_row.get(source_field, [])
+                if len(values) != len(scope_keys):
+                    raise RuntimeError(f"{method}.{source_field} does not cover all scopes")
+                row[output_field] = _finite(values[scope_index], positive=True)
+            rows.append(row)
+    if len(methods) != len(set(methods)) or len(methods) != 20:
+        raise RuntimeError(f"Expected 20 unique public methods, found {len(methods)}")
+    return methods, rows
+
+
+def _configuration_rows(
+    *,
+    dataset_key: str,
+    scope: dict[str, str],
+    runtime: str,
+) -> list[dict[str, Any]]:
+    import pandas as pd
+
+    from myapp.dataset_float_precision_distribution import filter_report_dataframe_for_float_precision
+    from myapp.home_leaderboard_boxplot_data import (
+        aggregate_report_rows_by_algorithm,
+        read_benchmark_report,
+    )
+
+    bundle_dir = BACKEND_DIR / "dataset" / dataset_key
+    report = read_benchmark_report(
+        bundle_dir,
+        dataset_key,
+        data_type=scope["data_type"],
+        implement_language=runtime,
+    )
+    if report is None or report.empty:
+        return []
+    if scope["data_type"] == "float":
+        report = filter_report_dataframe_for_float_precision(
+            report,
+            column_info_path=str(bundle_dir / f"{dataset_key}_column_info.csv"),
+            bundle_dir=str(bundle_dir),
+            float_precision=scope["float_precision"],
+        )
+    if report is None or report.empty:
+        return []
+
+    work = report.copy()
+    algorithm_keys = [str(value) for value in work["algorithm"].dropna().unique()]
+    enabled_by_key = {
+        key: _algorithm_metadata(key)[0]
+        for key in algorithm_keys
+    }
+    family_by_key = {key: _algorithm_metadata(key)[1] for key in algorithm_keys}
+    lossy_by_key = {key: _algorithm_metadata(key)[2] for key in algorithm_keys}
+    work = work[work["algorithm"].astype(str).map(enabled_by_key).fillna(False)].copy()
+    if work.empty:
+        return []
+    work["family"] = work["algorithm"].astype(str).map(family_by_key)
+    work = work[
+        work["family"].notna()
+        & ~work["algorithm"].astype(str).map(lossy_by_key).fillna(False)
+    ].copy()
+    if work.empty:
+        return []
+    for field in ("originalSize", "compressedSize", "compressionTime", "decompressionTime"):
+        work[field] = pd.to_numeric(work[field], errors="coerce")
+    work = work[
+        (work["originalSize"] > 0)
+        & (work["compressedSize"] > 0)
+        & (work["compressionTime"] >= 0)
+        & (work["decompressionTime"] >= 0)
+    ].copy()
+    if work.empty:
+        return []
+
+    aggregate = aggregate_report_rows_by_algorithm(work)
+    aggregate["family"] = aggregate["algorithm"].astype(str).map(family_by_key)
+    aggregate = aggregate[aggregate["family"].notna()].copy()
+    aggregate["compression_rate"] = aggregate["compressedSize"] / aggregate["originalSize"]
+    best_indexes = aggregate.groupby("family", sort=False)["compression_rate"].idxmin()
+    best_algorithms = set(aggregate.loc[best_indexes, "algorithm"].astype(str))
+
+    rows: list[dict[str, Any]] = []
+    for record in aggregate.itertuples(index=False):
+        original_bytes = _finite(record.originalSize, positive=True)
+        compressed_bytes = _finite(record.compressedSize, positive=True)
+        points = original_bytes / 8.0
+        compression_time_ns = _finite(record.compressionTime)
+        decompression_time_ns = _finite(record.decompressionTime)
+        rows.append(
+            {
+                "dataset": dataset_key,
+                "scope": scope["key"],
+                "runtime": runtime,
+                "method": str(record.algorithm),
+                "family": str(record.family),
+                "algorithm_variant": str(record.algorithm),
+                "is_best_rate_in_family": str(record.algorithm) in best_algorithms,
+                "original_size_bytes": int(round(original_bytes)),
+                "compressed_size_bytes": int(round(compressed_bytes)),
+                "point_count": int(round(points)),
+                "compression_time_ns": compression_time_ns,
+                "decompression_time_ns": decompression_time_ns,
+                "compression_rate": compressed_bytes / original_bytes,
+                "compression_time_ns_per_point": compression_time_ns / points,
+                "decompression_time_ns_per_point": decompression_time_ns / points,
+            }
+        )
+    return sorted(rows, key=lambda row: (row["method"], row["algorithm_variant"]))
+
+
+def _aggregate_current_rows(dataset_rows: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    configuration_aggregates: list[dict[str, Any]] = []
+    aggregates: list[dict[str, Any]] = []
+    configurations = sorted(
+        {
+            (row["runtime"], row["scope"], row["family"], row["method"])
+            for row in dataset_rows
+        }
+    )
+    for runtime, scope_key, family, method in configurations:
+        rows = [
+            row
+            for row in dataset_rows
+            if row["runtime"] == runtime
+            and row["scope"] == scope_key
+            and row["method"] == method
+        ]
+        configuration_aggregates.append(
+            _aggregate_rows(
+                rows,
+                runtime=runtime,
+                scope_key=scope_key,
+                method=method,
+                family=family,
+                algorithm_variant=method,
+            )
+        )
+
+    families = sorted(
+        {(row["runtime"], row["scope"], row["family"]) for row in dataset_rows}
+    )
+    for runtime, scope_key, family in families:
+            rows = [
+                row
+                for row in dataset_rows
+                if row["runtime"] == runtime
+                and row["scope"] == scope_key
+                and row["family"] == family
+                and row["is_best_rate_in_family"]
+            ]
+            if not rows:
+                continue
+            aggregates.append(
+                _aggregate_rows(
+                    rows,
+                    runtime=runtime,
+                    scope_key=scope_key,
+                    method=family,
+                    family=family,
+                    algorithm_variant=None,
+                )
+            )
+    return configuration_aggregates, aggregates
+
+
+def _aggregate_rows(
+    rows: list[dict[str, Any]],
+    *,
+    runtime: str,
+    scope_key: str,
+    method: str,
+    family: str,
+    algorithm_variant: str | None,
+) -> dict[str, Any]:
+    original_sum = sum(row["original_size_bytes"] for row in rows)
+    compressed_sum = sum(row["compressed_size_bytes"] for row in rows)
+    point_sum = sum(row["point_count"] for row in rows)
+    comp_time_sum = sum(row["compression_time_ns"] for row in rows)
+    decomp_time_sum = sum(row["decompression_time_ns"] for row in rows)
+    return {
+        "runtime": runtime,
+        "scope": scope_key,
+        "method": method,
+        "family": family,
+        "algorithm_variant": algorithm_variant,
+        "dataset_count": len(rows),
+        "overall_compression_rate": compressed_sum / original_sum,
+        "average_compression_rate": sum(row["compression_rate"] for row in rows) / len(rows),
+        "weighted_compression_time_ns_per_point": comp_time_sum / point_sum,
+        "average_compression_time_ns_per_point": sum(
+            row["compression_time_ns_per_point"] for row in rows
+        )
+        / len(rows),
+        "weighted_decompression_time_ns_per_point": decomp_time_sum / point_sum,
+        "average_decompression_time_ns_per_point": sum(
+            row["decompression_time_ns_per_point"] for row in rows
+        )
+        / len(rows),
+        "original_size_bytes": original_sum,
+        "compressed_size_bytes": compressed_sum,
+        "point_count": point_sum,
+    }
+
+
+def _source_status(path: Path) -> str:
+    relpath = path.relative_to(REPO_ROOT).as_posix()
+    tracked = subprocess.run(
+        ["git", "ls-files", "--error-unmatch", "--", relpath],
+        cwd=REPO_ROOT,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    ).returncode == 0
+    if not tracked:
+        return "generated_or_ignored"
+    return "tracked_modified" if _git("status", "--porcelain", "--", relpath) else "tracked_clean"
+
+
+def main() -> int:
+    sys.path.insert(0, str(BACKEND_DIR))
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")
+    import django
+
+    django.setup()
+
+    paper_snapshot = _read_json(SOURCE_PATHS["paper_table3"])
+    dataset_scope = _read_json(SOURCE_PATHS["dataset_scope"])
+    dataset_catalog = _read_json(SOURCE_PATHS["dataset_catalog"])
+    method_pipelines = _read_json(SOURCE_PATHS["method_pipelines"])
+
+    dataset_keys = [str(value) for value in dataset_scope["meta"]["dataset_keys"]]
+    if len(dataset_keys) != 19 or len(dataset_keys) != len(set(dataset_keys)):
+        raise RuntimeError(f"Expected 19 unique datasets, found {len(dataset_keys)}")
+    methods, paper_rows = _paper_rows(paper_snapshot)
+    datasets = _public_datasets(dataset_catalog, dataset_keys)
+
+    dataset_rows: list[dict[str, Any]] = []
+    for dataset_key in dataset_keys:
+        for scope in SCOPES:
+            for runtime in RUNTIMES:
+                dataset_rows.extend(
+                    _configuration_rows(
+                        dataset_key=dataset_key,
+                        scope=scope,
+                        runtime=runtime,
+                    )
+                )
+    configuration_aggregates, family_best_aggregates = _aggregate_current_rows(dataset_rows)
+    # Keep the published per-dataset payload compact. These totals are used above
+    # to produce the weighted aggregates; the UI needs the byte totals and
+    # per-point times, not duplicate time totals or the derivable point count.
+    for row in dataset_rows:
+        row.pop("compression_time_ns", None)
+        row.pop("decompression_time_ns", None)
+        row.pop("point_count", None)
+
+    families = sorted({row["family"] for row in dataset_rows})
+    configurations = sorted(
+        {(row["runtime"], row["method"], row["family"]) for row in dataset_rows}
+    )
+    method_definitions = sorted({(row["method"], row["family"]) for row in dataset_rows})
+    report_availability = []
+    report_paths_used: set[str] = set()
+    missing_report_count = 0
+    for dataset_key in dataset_keys:
+        for runtime in RUNTIMES:
+            available_types = []
+            for data_type in ("int", "float"):
+                path = BACKEND_DIR / "dataset" / dataset_key / f"{dataset_key}_{data_type}_{runtime}_compression_result.csv"
+                if path.is_file():
+                    available_types.append(data_type)
+                    report_paths_used.add(path.relative_to(REPO_ROOT).as_posix())
+                else:
+                    missing_report_count += 1
+            report_availability.append(
+                {
+                    "dataset": dataset_key,
+                    "runtime": runtime,
+                    "available_data_types": available_types,
+                }
+            )
+    source_files = [
+        {
+            "role": role,
+            "path": path.relative_to(REPO_ROOT).as_posix(),
+            "sha256": _sha256(path),
+            "status": _source_status(path),
+        }
+        for role, path in SOURCE_PATHS.items()
+    ]
+    report_files = [
+        {
+            "path": relpath,
+            "size_bytes": (REPO_ROOT / relpath).stat().st_size,
+            "sha256": _sha256(REPO_ROOT / relpath),
+        }
+        for relpath in sorted(report_paths_used)
+    ]
+
+    pipeline_map = method_pipelines.get("pipelines", {})
+    method_rows = [
+        {
+            "name": method,
+            "family": family,
+            "runtimes": sorted(
+                runtime
+                for runtime, configuration, configuration_family in configurations
+                if configuration == method and configuration_family == family
+            ),
+            "operator_pipeline": pipeline_map.get(family),
+            "operator_pipeline_status": (
+                "interpretive_coarse_mapping" if family in pipeline_map else "not_available"
+            ),
+        }
+        for method, family in method_definitions
+    ]
+
+    scope_summary = dataset_scope["summary"]
+    current_cpp_family_keys = {
+        (row["scope"], row["family"])
+        for row in family_best_aggregates
+        if row["runtime"] == "cpp"
+    }
+    paper_keys = {(row["scope"], row["method"]) for row in paper_rows}
+    dirty_inputs = [
+        row["path"] for row in source_files if row["status"] == "tracked_modified"
+    ]
+    data = {
+        "schema_version": 1,
+        "benchmark": {
+            "title": "THULab Time Series Compression Benchmark",
+            "implementation_runtimes": list(RUNTIMES),
+            "lossless_only": True,
+            "current_result_selection": "all visible lossless algorithm configurations measured in the 19-dataset scope",
+            "paper_result_selection": "the separate paper_table3 section contains its frozen 20-method C++ snapshot",
+            "scope_note": "Current result rows cover numeric int/float report evidence for the retained 19 public datasets. They reflect the columns present in each report; they do not assert full-column coverage beyond those files.",
+            "aggregation_note": "Average metrics are arithmetic means over available per-dataset measurements. Overall compression rate and weighted times use summed measured bytes, points, and nanoseconds only.",
+            "selection_note": "Configuration views retain every visible measured lossless configuration. Family views choose the lowest-rate configuration independently for each dataset, scope, and runtime.",
+            "notes": [
+                "Missing combinations are unavailable rather than zero.",
+                "Hardware identity and round-trip verification are not reported by these source CSVs.",
+                "The frozen paper table is labeled separately from the current report-tree recomputation.",
+            ],
+            "metric_definitions": {
+                "compression_rate": "compressed bytes divided by original numeric bytes; lower is better",
+                "average_compression_rate": "arithmetic mean of per-dataset compression rates",
+                "overall_compression_rate": "sum of compressed bytes divided by sum of original numeric bytes",
+                "average_time_ns_per_point": "arithmetic mean of per-dataset nanoseconds per 8-byte numeric point",
+                "weighted_time_ns_per_point": "sum of measured nanoseconds divided by sum of 8-byte numeric points",
+                "paper_median_balanced_score": "stored paper snapshot value; normalization is paper-scope specific and lower is better",
+            },
+            "measurement_boundaries": [
+                "No hardware identity is attached because the selected source files do not provide one.",
+                "No round-trip verification claim is exported from timing/result CSVs alone.",
+                "Family-level aggregates select the measured variant with the lowest compression rate within each dataset and method family, matching the backend family-selection rule.",
+                "dataset_results contains every visible measured configuration; is_best_rate_in_family marks the configuration used for family-level aggregation.",
+                "Paper Table 3 values and current report recomputations are separate result sets because the report tree has evolved since the paper snapshot was frozen.",
+            ],
+        },
+        "source": {
+            "generated_at": dataset_scope.get("generated_at") or dataset_scope["meta"].get("generated_at"),
+            "git_commit": _git("rev-parse", "HEAD"),
+            "source_files": source_files,
+            "worktree_dirty_inputs": dirty_inputs,
+            "result_csv_pattern": "backend/dataset/<dataset>/<dataset>_<int|float>_<cpp|java|python>_compression_result.csv",
+            "result_csv_files_used": report_files,
+        },
+        "coverage": {
+            "dataset_count": len(dataset_keys),
+            "runtime_count": len(RUNTIMES),
+            "runtimes": list(RUNTIMES),
+            "method_family_count": len(families),
+            "method_configuration_count": len(method_definitions),
+            "runtime_configuration_count": len(configurations),
+            "scope_count": len(SCOPES),
+            "paper_leaderboard_row_count": len(paper_rows),
+            "configuration_aggregate_row_count": len(configuration_aggregates),
+            "family_best_aggregate_row_count": len(family_best_aggregates),
+            "dataset_result_row_count": len(dataset_rows),
+            "source_report_file_count": len(report_files),
+            "missing_source_report_count": missing_report_count,
+            "excluded_datasets": dataset_scope["meta"].get("excluded_dataset_keys", []),
+            "missing_measurement_policy": "Missing report and dataset/scope/runtime/configuration combinations are omitted; the UI must display them as unavailable, never as zero.",
+        },
+        "dataset_overview": {
+            "dataset_count": scope_summary["dataset_count"],
+            "total_rows": scope_summary["total_rows"],
+            "total_size_bytes": scope_summary["total_size_bytes"],
+            "total_compressed_size_bytes": scope_summary["total_compressed_size_bytes"],
+            "overall_compression_rate": scope_summary["overall_compression_rate"],
+            "average_compression_rate": scope_summary["average_compression_rate"],
+            "compression_rate_used_column_count": dataset_scope["meta"].get("compression_rate_used_column_count"),
+            "compression_rate_missing_column_count": dataset_scope["meta"].get("compression_rate_missing_column_count"),
+            "compression_rate_missing_examples": dataset_scope["meta"].get("compression_rate_missing_examples", []),
+            "provenance_note": dataset_scope["meta"].get("compression_rate_recompute"),
+        },
+        "scopes": list(SCOPES),
+        "report_availability": report_availability,
+        "datasets": datasets,
+        "methods": method_rows,
+        "paper_table3": {
+            "source_note": paper_snapshot.get("source"),
+            "comparison_to_current_reports": {
+                "status": "separate_frozen_view",
+                "exact_name_overlap_row_count": len(paper_keys & current_cpp_family_keys),
+                "paper_row_count": len(paper_keys),
+                "unmatched_paper_method_names": sorted(
+                    {method for _scope, method in paper_keys - current_cpp_family_keys}
+                ),
+                "note": "The frozen table is not used to fill or overwrite current report values; method labels and measurements have evolved.",
+            },
+            "rows": paper_rows,
+        },
+        "configuration_aggregates": configuration_aggregates,
+        "family_best_aggregates": family_best_aggregates,
+        "dataset_results": dataset_rows,
+    }
+
+    data_path = EXPORT_DIR / "data.json"
+    data_path.write_text(
+        json.dumps(data, ensure_ascii=False, separators=(",", ":"), sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    manifest = {
+        "schema_version": 1,
+        "data_file": "data.json",
+        "data_sha256": _sha256(data_path),
+        "counts": data["coverage"],
+        "source_files": source_files,
+        "result_csv_files": report_files,
+        "excluded_content": [
+            "raw datasets",
+            "user uploads",
+            "credentials and environment variables",
+            "server logs",
+            "binaries and model artifacts",
+            "external or vendored benchmark results",
+        ],
+    }
+    (EXPORT_DIR / "manifest.json").write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+    print(json.dumps(manifest["counts"], ensure_ascii=False, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

index.html

@@ -1,19 +1,102 @@
 <!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="THULab time-series compression benchmark: measured compression rates, encoding and decoding costs, and dataset coverage.">
+  <meta name="color-scheme" content="light dark">
+  <title>THULab | Time Series Compression Benchmark</title>
+  <link rel="stylesheet" href="style.css">
+  <script src="app.js" type="module"></script>
+</head>
+<body>
+  <a class="skip-link" href="#content">Skip to results</a>
+  <header class="site-header">
+    <a class="brand" href="#overall"><span class="brand-mark">THU</span><span>THULab <span class="brand-sub">Compression Benchmark</span></span></a>
+    <div class="header-links"><a href="https://github.com/xjz17/web_compression" target="_blank" rel="noopener">Project code ↗</a><button id="theme" class="quiet-button" type="button" aria-label="Switch color theme">Theme</button></div>
+  </header>
+  <main id="content">
+    <section class="intro" aria-labelledby="title">
+      <p class="eyebrow">Time-series systems research</p>
+      <h1 id="title">Time Series Compression Leaderboard</h1>
+      <p class="intro-text">Compare measured storage, encoding, and decoding costs across real time-series datasets.</p>
+      <p class="snapshot" id="snapshot">Loading benchmark snapshot…</p>
+    </section>
+    <div class="summary-strip" id="summary" aria-label="Snapshot coverage">
+      <div><strong id="dataset-count">…</strong><span>datasets with results</span></div>
+      <div><strong id="method-count">…</strong><span>method families</span></div>
+      <div><strong id="runtime-count">…</strong><span>implementation runtimes</span></div>
+      <div><strong id="record-count">…</strong><span>runtime / codec configurations</span></div>
+    </div>
+    <nav class="tabs" aria-label="Benchmark views">
+      <button id="tab-overall" class="tab active" data-tab="overall" aria-current="page">Overall</button>
+      <button id="tab-dataset" class="tab" data-tab="dataset">By dataset</button>
+      <button id="tab-tradeoffs" class="tab" data-tab="tradeoffs">Trade-offs</button>
+      <button id="tab-methods" class="tab" data-tab="methods">Methods</button>
+      <button id="tab-paper" class="tab" data-tab="paper">Paper snapshot</button>
+      <button id="tab-about" class="tab" data-tab="about">About</button>
+    </nav>
+    <div id="load-error" class="error-message" role="alert" hidden></div>
+    <section id="results-view" aria-label="Compression results">
+      <div class="filters" id="filters">
+        <label>Runtime<select id="runtime"></select></label>
+        <label>Data type<select id="dtype"><option value="overall">All numeric</option><option value="int">Integer</option><option value="float">Floating point</option></select></label>
+        <label>Float precision<select id="precision"><option value="all">All precision</option><option value="fixed">Fixed precision</option><option value="non_fixed">Non-fixed precision</option></select></label>
+        <label>Dataset<select id="dataset"><option value="all">All datasets</option></select></label>
+        <label>Method rows<select id="row-mode"><option value="family">Best measured per family</option><option value="configuration">Exact configuration</option></select></label>
+        <label>Method family<select id="family"><option value="all">All families</option></select></label>
+        <label class="search-field">Find a method<input id="search" type="search" placeholder="e.g. REGER, Zstd, Gorilla" autocomplete="off"></label>
+      </div>
+      <div class="toolbar">
+        <div><h2 id="view-title">Overall leaderboard</h2><p id="selection-summary" class="muted" aria-live="polite">Reading published results…</p></div>
+        <div class="toolbar-actions"><button id="reset" class="quiet-button">Reset filters</button><button id="download" class="primary-button" disabled>Download CSV</button></div>
+      </div>
+      <div class="results-note" id="results-note">Compression rate = compressed bytes / original bytes. Lower rates and lower ns/point are better.</div>
+      <div class="table-settings">
+        <label><input id="complete-only" type="checkbox"> Only methods covering the full selection</label>
+        <details><summary>Display columns</summary><div id="column-options" class="column-options"></div></details>
+      </div>
+      <div id="chart-view" hidden>
+        <div class="chart-controls"><label>Vertical axis<select id="chart-metric"><option value="compression_time">Encoding cost (ns/point)</option><option value="decompression_time">Decoding cost (ns/point)</option></select></label><span class="muted">Lower and further left is better. Click a point for method details.</span></div>
+        <div id="chart" class="chart" aria-label="Compression rate and execution cost scatter plot"></div>
+      </div>
+      <div id="leaderboard-wrap" class="table-wrap" tabindex="0" aria-label="Scrollable sortable leaderboard">
+        <table id="leaderboard"><thead></thead><tbody><tr><td class="loading-cell">Loading measured results…</td></tr></tbody></table>
+      </div>
+      <div class="table-footer"><span id="row-count" aria-live="polite"></span><span>Select a method to inspect dataset-level results.</span></div>
+      <section id="method-detail" class="method-detail" hidden tabindex="-1" aria-labelledby="detail-title"></section>
+    </section>
+    <section id="methods-view" class="text-view" hidden><h2>Method configurations</h2><p class="muted">Names and parameters are retained from the project's result files. Availability can differ by runtime and data type.</p><div id="method-catalog"></div></section>
+    <section id="paper-view" class="text-view" hidden>
+      <h2>Frozen paper Table 3 snapshot</h2>
+      <p class="notice">These stored C++ results reproduce the project's frozen paper table. They are separate from the current report-tree leaderboard because source reports and method labels have evolved.</p>
+      <label style="max-width:300px;margin:20px 0">Paper data scope<select id="paper-scope"><option value="overall">All numeric</option><option value="integer">Integer</option><option value="fixed_float">Fixed-precision float</option><option value="nonfixed_float">Non-fixed-precision float</option></select></label>
+      <div class="table-wrap"><table id="paper-table"><thead><tr><th>Method</th><th>Stored rank</th><th>Average rate ↓</th><th>Encode ns/point ↓</th><th>Decode ns/point ↓</th><th>Stored balanced score ↓</th></tr></thead><tbody></tbody></table></div>
+      <p class="muted" style="margin-top:14px">Stored rank and balanced score retain the source table's aggregation. The current leaderboard does not use these values to fill missing measurements.</p>
+    </section>
+    <section id="about-view" class="text-view" hidden>
+      <h2>About this benchmark</h2>
+      <p>This Space publishes a snapshot of the existing <a href="https://github.com/xjz17/web_compression" target="_blank" rel="noopener">web_compression</a> project results. The layout follows the grouped leaderboard approach of <a href="https://huggingface.co/spaces/Salesforce/GIFT-Eval" target="_blank" rel="noopener">GIFT-Eval</a>.</p>
+      <div id="methodology"></div>
+      <h3>Metric definitions</h3>
+      <dl class="definitions">
+        <div><dt>Average compression rate ↓</dt><dd>Arithmetic mean of the per-dataset compression rates in the selected scope.</dd></div>
+        <div><dt>Overall compression rate ↓</dt><dd>Total compressed bytes divided by total original bytes over the selected measured records.</dd></div>
+        <div><dt>Encoding / decoding cost ↓</dt><dd>Nanoseconds per data point. The aggregation boundary is documented with the snapshot below.</dd></div>
+        <div><dt>Coverage</dt><dd>Datasets with usable measurements for a method out of the datasets in the selected scope. Missing results are never filled with zero.</dd></div>
+      </dl>
+      <h3>Reading the rankings</h3>
+      <p>Methods with different coverage are measured on different inputs. Coverage counts datasets, not identical columns or point counts. Use the full-coverage filter and inspect a single dataset's input sizes before drawing a direct comparison. Runtime filters keep Python, C++, and Java measurements separate.</p>
+      <p>By default, each family uses its measured configuration with the lowest compression rate in each dataset. The chosen configuration can vary by dataset. Switch Method rows to Exact configuration to compare a fixed configuration; method details show the exact variant used.</p>
+      <p>These are published measurements, not experiments executed inside this Space. A reported ratio alone does not establish lossless reconstruction; round-trip checks and hardware details are shown only when their evidence exists in the source snapshot.</p>
+      <h3>Download and provenance</h3>
+      <p><a href="data.json" download>Result snapshot (JSON)</a> · <a href="manifest.json" download>Source manifest (JSON)</a></p>
+      <div id="provenance"></div>
+      <h3>Contribute a result</h3>
+      <p>Run the project benchmark and provide the codec/configuration, input identity, encoding and decoding measurements, execution environment, and round-trip validation evidence. Results can be updated from the source project using the snapshot exporter included in the Space repository.</p>
+    </section>
+    <noscript><p class="error-message">Enable JavaScript to filter and sort this leaderboard. You can also download <a href="data.json">the results JSON</a>.</p></noscript>
+    <footer><span>THULab · Time Series Compression Benchmark</span><span id="footer-snapshot"></span></footer>
+  </main>
+</body>
 </html>

manifest.json

@@ -0,0 +1,634 @@
+{
+  "counts": {
+    "configuration_aggregate_row_count": 4653,
+    "dataset_count": 19,
+    "dataset_result_row_count": 67200,
+    "excluded_datasets": [
+      "poisson_timestamps"
+    ],
+    "family_best_aggregate_row_count": 1383,
+    "method_configuration_count": 311,
+    "method_family_count": 93,
+    "missing_measurement_policy": "Missing report and dataset/scope/runtime/configuration combinations are omitted; the UI must display them as unavailable, never as zero.",
+    "missing_source_report_count": 0,
+    "paper_leaderboard_row_count": 80,
+    "runtime_configuration_count": 931,
+    "runtime_count": 3,
+    "runtimes": [
+      "cpp",
+      "java",
+      "python"
+    ],
+    "scope_count": 5,
+    "source_report_file_count": 114
+  },
+  "data_file": "data.json",
+  "data_sha256": "b5230a0518ec3939048f0ce5731c2a29a661e98e3f493709c92fb260871b5e1c",
+  "excluded_content": [
+    "raw datasets",
+    "user uploads",
+    "credentials and environment variables",
+    "server logs",
+    "binaries and model artifacts",
+    "external or vendored benchmark results"
+  ],
+  "result_csv_files": [
+    {
+      "path": "backend/dataset/Air-Quality/Air-Quality_float_cpp_compression_result.csv",
+      "sha256": "0b87cd9ff45e94cd9a102de54f75b0ac5b7a12367c8f9c5c30810148c0bcd28a",
+      "size_bytes": 76356
+    },
+    {
+      "path": "backend/dataset/Air-Quality/Air-Quality_float_java_compression_result.csv",
+      "sha256": "1be96ae86bc3e5676368c219403d3e0520615b960e8c3ac5e438a93c0db715f8",
+      "size_bytes": 75419
+    },
+    {
+      "path": "backend/dataset/Air-Quality/Air-Quality_float_python_compression_result.csv",
+      "sha256": "5801891836cdb3f8b901365af13b357bf7f48ffbc868ba974fa38fd7badbaeac",
+      "size_bytes": 91701
+    },
+    {
+      "path": "backend/dataset/Air-Quality/Air-Quality_int_cpp_compression_result.csv",
+      "sha256": "a311037d54f9e686acb31b5d659e4cc29a222632074fa81f226bd64a6876e8a3",
+      "size_bytes": 117640
+    },
+    {
+      "path": "backend/dataset/Air-Quality/Air-Quality_int_java_compression_result.csv",
+      "sha256": "343154d54db87f84766b7dd22a1b02af6a2fb4c5fcfc99255b2b4a7869bef24d",
+      "size_bytes": 117108
+    },
+    {
+      "path": "backend/dataset/Air-Quality/Air-Quality_int_python_compression_result.csv",
+      "sha256": "904c9c0253c10953b6cbfa73a13440bfc3024d02e41a3e43ea1f7ae5bfd6b196",
+      "size_bytes": 119582
+    },
+    {
+      "path": "backend/dataset/Arade/Arade_float_cpp_compression_result.csv",
+      "sha256": "79f2c8905a794fde576f216de22ae0abf6f1eff9ca91e05bc738b0637f44a6c7",
+      "size_bytes": 71234
+    },
+    {
+      "path": "backend/dataset/Arade/Arade_float_java_compression_result.csv",
+      "sha256": "dcab3fcf3bd332c951c5f64c23407be20e6f57ac6dc600c2496fa6787f874999",
+      "size_bytes": 72638
+    },
+    {
+      "path": "backend/dataset/Arade/Arade_float_python_compression_result.csv",
+      "sha256": "03681d3372fbf73ea66c09cdace5c31ea255e5d1387377a85999224cde60446a",
+      "size_bytes": 13884
+    },
+    {
+      "path": "backend/dataset/Arade/Arade_int_cpp_compression_result.csv",
+      "sha256": "93e718edce0a6800cdb68bb33c512dcae657be9b3a5d35e2a02c8e655a38a1cd",
+      "size_bytes": 35581
+    },
+    {
+      "path": "backend/dataset/Arade/Arade_int_java_compression_result.csv",
+      "sha256": "3bffb83c23d2865f7776657327274a1f67ddeb3c194df5bc1004e7d4ad2eca38",
+      "size_bytes": 36864
+    },
+    {
+      "path": "backend/dataset/Arade/Arade_int_python_compression_result.csv",
+      "sha256": "2aa8734913bbb9ca28de8465f1ed201a39068ad7134bed1e54606cb8b7a38ad7",
+      "size_bytes": 32329
+    },
+    {
+      "path": "backend/dataset/Bar-Crawl/Bar-Crawl_float_cpp_compression_result.csv",
+      "sha256": "736ffdaaac2a5863546262128c58cb1b63062e4bcff2094d54114a32e72bf5dd",
+      "size_bytes": 57117
+    },
+    {
+      "path": "backend/dataset/Bar-Crawl/Bar-Crawl_float_java_compression_result.csv",
+      "sha256": "9dcd1245a330236139f31e16da5ae273d715557d23e1ba435d965470f8194e40",
+      "size_bytes": 55082
+    },
+    {
+      "path": "backend/dataset/Bar-Crawl/Bar-Crawl_float_python_compression_result.csv",
+      "sha256": "4713cbd181babc9a09e7515e38cdbc32c547205dbed4e88a2b9c0bb91d5b7134",
+      "size_bytes": 42132
+    },
+    {
+      "path": "backend/dataset/Bar-Crawl/Bar-Crawl_int_cpp_compression_result.csv",
+      "sha256": "72f46e0ca40bed03e8f905ce37f495fed7824678c11967ac2507bc1945b81b61",
+      "size_bytes": 20079
+    },
+    {
+      "path": "backend/dataset/Bar-Crawl/Bar-Crawl_int_java_compression_result.csv",
+      "sha256": "0094190b6f8330546cde4639fdb333dd6405fd0f4b0ae36bbd4d7bfbefa78543",
+      "size_bytes": 18172
+    },
+    {
+      "path": "backend/dataset/Bar-Crawl/Bar-Crawl_int_python_compression_result.csv",
+      "sha256": "68325556c32a042a21da1c09a113a315e06f55a7c4bb993515f66c923738d713",
+      "size_bytes": 22882
+    },
+    {
+      "path": "backend/dataset/Bird-migration/Bird-migration_float_cpp_compression_result.csv",
+      "sha256": "c7e52f8b3d2767ce87230af0c61aa17552740d1eb6f4edb0973e335739a5ae58",
+      "size_bytes": 65366
+    },
+    {
+      "path": "backend/dataset/Bird-migration/Bird-migration_float_java_compression_result.csv",
+      "sha256": "6b0d399618db9bad6938e177f74c8dc29f87b0b2f8a02ebc202c1456b3e645c2",
+      "size_bytes": 65554
+    },
+    {
+      "path": "backend/dataset/Bird-migration/Bird-migration_float_python_compression_result.csv",
+      "sha256": "57089ce22abfb23b942c1889a8776ea386401953d303235d15a3b15e1ca8f1e9",
+      "size_bytes": 22924
+    },
+    {
+      "path": "backend/dataset/Bird-migration/Bird-migration_int_cpp_compression_result.csv",
+      "sha256": "949023586b284504bd2409c6a5c813f69609ccc545edbbc28603d5a3ff495eb7",
+      "size_bytes": 33307
+    },
+    {
+      "path": "backend/dataset/Bird-migration/Bird-migration_int_java_compression_result.csv",
+      "sha256": "d994c9353aa8912ee23b8eb9414691dc3c75dcbc667d5d86e71decebd77351a5",
+      "size_bytes": 30909
+    },
+    {
+      "path": "backend/dataset/Bird-migration/Bird-migration_int_python_compression_result.csv",
+      "sha256": "f40db74282779f049daa21201ef5e747582d8597ca4ba3df92e5ca17633ff859",
+      "size_bytes": 34474
+    },
+    {
+      "path": "backend/dataset/Comments/Comments_float_cpp_compression_result.csv",
+      "sha256": "fd3786d13e3536d57d207fa8cc8c1398266608fd7b60fdca6e9091af5a3b41da",
+      "size_bytes": 18124
+    },
+    {
+      "path": "backend/dataset/Comments/Comments_float_java_compression_result.csv",
+      "sha256": "55f634c16982de565f373bbef978ed8fb921c7569ab62ca5cdafca597070c481",
+      "size_bytes": 16509
+    },
+    {
+      "path": "backend/dataset/Comments/Comments_float_python_compression_result.csv",
+      "sha256": "8f9acf4393f700cde2c458646d634854d87d4a17a362a5790074c8d19aebb356",
+      "size_bytes": 3128
+    },
+    {
+      "path": "backend/dataset/Comments/Comments_int_cpp_compression_result.csv",
+      "sha256": "677e9684d67cced9dc4a58847d78e17924bca63ed12c4ae605c1a38be6f0f9cc",
+      "size_bytes": 35212
+    },
+    {
+      "path": "backend/dataset/Comments/Comments_int_java_compression_result.csv",
+      "sha256": "4134b9f2132f9308eac53fdadd8bc4df5f2357b3bd05b94d0f0afa3e04548fd4",
+      "size_bytes": 33581
+    },
+    {
+      "path": "backend/dataset/Comments/Comments_int_python_compression_result.csv",
+      "sha256": "7fa68956efd7a24cc60f9bed9c2021d8fb852913e57a9d89e3339c9c315d9a0c",
+      "size_bytes": 34501
+    },
+    {
+      "path": "backend/dataset/IGlocations2/IGlocations2_float_cpp_compression_result.csv",
+      "sha256": "fd3ab75f117ec5bd3dd1406667894f6a9bd6507a8d57a27c95d8cf3dc2ddd480",
+      "size_bytes": 86071
+    },
+    {
+      "path": "backend/dataset/IGlocations2/IGlocations2_float_java_compression_result.csv",
+      "sha256": "f3e764b128acf8400e9a187eaf80870cd81ec4c0f128626654fc1a121ffe57bc",
+      "size_bytes": 83581
+    },
+    {
+      "path": "backend/dataset/IGlocations2/IGlocations2_float_python_compression_result.csv",
+      "sha256": "2da445321ef3a3301f24c30aed61138ec7839c1ad043015de319a65c3ecf8c0a",
+      "size_bytes": 56079
+    },
+    {
+      "path": "backend/dataset/IGlocations2/IGlocations2_int_cpp_compression_result.csv",
+      "sha256": "a0dad469fafeef59b86ae63619c084d6557290655e9655eac7e6ff2d7ac06a16",
+      "size_bytes": 34783
+    },
+    {
+      "path": "backend/dataset/IGlocations2/IGlocations2_int_java_compression_result.csv",
+      "sha256": "efb4f54e80d077891cd8985b1d77792afa4c996a3f1d07ffea9e8b29177fea48",
+      "size_bytes": 33207
+    },
+    {
+      "path": "backend/dataset/IGlocations2/IGlocations2_int_python_compression_result.csv",
+      "sha256": "7d1989329063258719da15ad66e1a86708d35c4d5a47e10462c02366b7a98647",
+      "size_bytes": 4511
+    },
+    {
+      "path": "backend/dataset/Metro-Traffic/Metro-Traffic_float_cpp_compression_result.csv",
+      "sha256": "22f6b71e471fd423e85aa8bde16691c66d517d2fc80ff97b0149926af91e80c4",
+      "size_bytes": 46643
+    },
+    {
+      "path": "backend/dataset/Metro-Traffic/Metro-Traffic_float_java_compression_result.csv",
+      "sha256": "c4f2dc770a4b5665c88319df5d5ee0db47143bc19533015de44c6138b3500584",
+      "size_bytes": 45929
+    },
+    {
+      "path": "backend/dataset/Metro-Traffic/Metro-Traffic_float_python_compression_result.csv",
+      "sha256": "63ce12b59340bc528acea98c097bcbed5fd39b6046715bd63f645d0d5372dd29",
+      "size_bytes": 45791
+    },
+    {
+      "path": "backend/dataset/Metro-Traffic/Metro-Traffic_int_cpp_compression_result.csv",
+      "sha256": "9f75dcc5f490f7ffafb5255e4aad2a2d0f3019527bdfc10bb472d65c6afbf715",
+      "size_bytes": 32083
+    },
+    {
+      "path": "backend/dataset/Metro-Traffic/Metro-Traffic_int_java_compression_result.csv",
+      "sha256": "25477f3ea4e05c8a9d591b661a6e17d0b53997fc874e49545fa96180e55f436f",
+      "size_bytes": 31200
+    },
+    {
+      "path": "backend/dataset/Metro-Traffic/Metro-Traffic_int_python_compression_result.csv",
+      "sha256": "52c8b731d4045c103e39e1b884956c9de628a6d8085d8a5354870492e5e5a1fa",
+      "size_bytes": 34564
+    },
+    {
+      "path": "backend/dataset/NYC_Yellow_Taxi_Trip/NYC_Yellow_Taxi_Trip_float_cpp_compression_result.csv",
+      "sha256": "94c633665c9aff9d860559f68bd7379f71d46de2c382ac233709c21199513c8d",
+      "size_bytes": 216037
+    },
+    {
+      "path": "backend/dataset/NYC_Yellow_Taxi_Trip/NYC_Yellow_Taxi_Trip_float_java_compression_result.csv",
+      "sha256": "3702f4c49c2902ed39271d88b3dbdf268f1a118d71070d575af49a605916899e",
+      "size_bytes": 223962
+    },
+    {
+      "path": "backend/dataset/NYC_Yellow_Taxi_Trip/NYC_Yellow_Taxi_Trip_float_python_compression_result.csv",
+      "sha256": "84c211e8758a7ceed4df0cb9e30402bf92217734eab1f7d8bac7e8f8f8841b25",
+      "size_bytes": 9697
+    },
+    {
+      "path": "backend/dataset/NYC_Yellow_Taxi_Trip/NYC_Yellow_Taxi_Trip_int_cpp_compression_result.csv",
+      "sha256": "611d0816b064542b76ca1a4c208c3fffeec860f70a2c3a5ad3963c638a0d187e",
+      "size_bytes": 70605
+    },
+    {
+      "path": "backend/dataset/NYC_Yellow_Taxi_Trip/NYC_Yellow_Taxi_Trip_int_java_compression_result.csv",
+      "sha256": "2b92683188cd0bd9c311b555579e39241f39762867d0089a56f876a1e34e8fda",
+      "size_bytes": 73797
+    },
+    {
+      "path": "backend/dataset/NYC_Yellow_Taxi_Trip/NYC_Yellow_Taxi_Trip_int_python_compression_result.csv",
+      "sha256": "4c2bcdf1c6768533803662fbd565443997c29e55a61e920a0b895903e91a63e2",
+      "size_bytes": 67898
+    },
+    {
+      "path": "backend/dataset/RealEstate1/RealEstate1_float_cpp_compression_result.csv",
+      "sha256": "728ad92ed3098b011c1ecf85af523f360fb6da39879817519dce3c22ffddd5ce",
+      "size_bytes": 88891
+    },
+    {
+      "path": "backend/dataset/RealEstate1/RealEstate1_float_java_compression_result.csv",
+      "sha256": "438d6392642a2ca8d9573411ea1839af9dba74877a8165394c9856627df83e0f",
+      "size_bytes": 88991
+    },
+    {
+      "path": "backend/dataset/RealEstate1/RealEstate1_float_python_compression_result.csv",
+      "sha256": "ddc29581e1261f588f1556e45a0128bfbfd54bc83aa9a143c3b72f377d33dea4",
+      "size_bytes": 39467
+    },
+    {
+      "path": "backend/dataset/RealEstate1/RealEstate1_int_cpp_compression_result.csv",
+      "sha256": "4b535911b2b53d763fcb3999e6a7354f9aff87727b3b9cfc0ce08c876d5a455f",
+      "size_bytes": 87226
+    },
+    {
+      "path": "backend/dataset/RealEstate1/RealEstate1_int_java_compression_result.csv",
+      "sha256": "13fa8d59799bbcc1ca81c73127cf3fb912085fecc7166fcda55ac02a770fd13c",
+      "size_bytes": 92944
+    },
+    {
+      "path": "backend/dataset/RealEstate1/RealEstate1_int_python_compression_result.csv",
+      "sha256": "73eade2aba7f73a651de9536ac85ba96f5580b24a37b7bfcb43233d333852e09",
+      "size_bytes": 6620
+    },
+    {
+      "path": "backend/dataset/RealEstate2/RealEstate2_float_cpp_compression_result.csv",
+      "sha256": "b0029cb3cdb7fee3a8973e1f7f60651804ad6a78df598ceaf63253d73453d9b1",
+      "size_bytes": 35349
+    },
+    {
+      "path": "backend/dataset/RealEstate2/RealEstate2_float_java_compression_result.csv",
+      "sha256": "a75b9b5ed7c3e39f2f77d447f7c0f5bbcb1215590fe0278a9539949a5619b245",
+      "size_bytes": 35210
+    },
+    {
+      "path": "backend/dataset/RealEstate2/RealEstate2_float_python_compression_result.csv",
+      "sha256": "bae1db5d9be2e250caaed514eb21cab33f39a928b46353749817e822c62d6ac1",
+      "size_bytes": 34867
+    },
+    {
+      "path": "backend/dataset/RealEstate2/RealEstate2_int_cpp_compression_result.csv",
+      "sha256": "613d9c5660c5022a64ca8c461623f7f8a2bbcb1014957c6401f65ecbdf3e9519",
+      "size_bytes": 34143
+    },
+    {
+      "path": "backend/dataset/RealEstate2/RealEstate2_int_java_compression_result.csv",
+      "sha256": "56f6da15a89377371aafdcd4e08dc334bbab41db095ffecc099b49e4b05f84f6",
+      "size_bytes": 34450
+    },
+    {
+      "path": "backend/dataset/RealEstate2/RealEstate2_int_python_compression_result.csv",
+      "sha256": "9636cb52789774f254a110186ec5e2cf0b3d6def49ad5637ea16910106255bf8",
+      "size_bytes": 32121
+    },
+    {
+      "path": "backend/dataset/Romance/Romance_float_cpp_compression_result.csv",
+      "sha256": "4fb1203fa2cf71b854d6c6504108b1c174585eea394b4381af53b5b9e6f8dd99",
+      "size_bytes": 82518
+    },
+    {
+      "path": "backend/dataset/Romance/Romance_float_java_compression_result.csv",
+      "sha256": "bf9de658d12d6d8a9ac1f801cffa91aa524ca14ae317460719c8c6a99f14e7f8",
+      "size_bytes": 80897
+    },
+    {
+      "path": "backend/dataset/Romance/Romance_float_python_compression_result.csv",
+      "sha256": "628c35aa5722aac14409faba75434ebf50b3d91375d69cda3b3ece297ce6aff2",
+      "size_bytes": 78280
+    },
+    {
+      "path": "backend/dataset/Romance/Romance_int_cpp_compression_result.csv",
+      "sha256": "8edeab8c2487bae130e1467fac6865ceddbf6c345e2304226daa521d68d4c11c",
+      "size_bytes": 17199
+    },
+    {
+      "path": "backend/dataset/Romance/Romance_int_java_compression_result.csv",
+      "sha256": "73fca75713bdf84d2564bfdb5e1d9b97d4019ddc58f63b0b8a686c658c00b0cb",
+      "size_bytes": 16045
+    },
+    {
+      "path": "backend/dataset/Romance/Romance_int_python_compression_result.csv",
+      "sha256": "4f9eb0434ea4b3c3ed55843c405baf49560322449d57d4bf673d0f59bfdb57e3",
+      "size_bytes": 18001
+    },
+    {
+      "path": "backend/dataset/Telco/Telco_float_cpp_compression_result.csv",
+      "sha256": "81339896d520d5d0c7e66b88265ec01e74f8eba053428a0c2465ac359a49bd8b",
+      "size_bytes": 2259362
+    },
+    {
+      "path": "backend/dataset/Telco/Telco_float_java_compression_result.csv",
+      "sha256": "ced2900ee48b628b0cff5406bab3437e5533e01a65928d2c84931d59a0e9019a",
+      "size_bytes": 2386699
+    },
+    {
+      "path": "backend/dataset/Telco/Telco_float_python_compression_result.csv",
+      "sha256": "54df35123e215233d23ac30c9aab28a34394ee70c2b7248a91671be1d182aff3",
+      "size_bytes": 2307336
+    },
+    {
+      "path": "backend/dataset/Telco/Telco_int_cpp_compression_result.csv",
+      "sha256": "c8b8c3ed39b4a84ab3f3cfc75d8c26f1701c6a1534fc13e52d1c5a346886ea10",
+      "size_bytes": 686240
+    },
+    {
+      "path": "backend/dataset/Telco/Telco_int_java_compression_result.csv",
+      "sha256": "fb136021794f4c62a462f843681da8e9710b55d869a683f0eab8d59965c5ae72",
+      "size_bytes": 685490
+    },
+    {
+      "path": "backend/dataset/Telco/Telco_int_python_compression_result.csv",
+      "sha256": "0f442adf6601a981277edb29f30cc793ffb11edc6afbdccdd484ef8bff89e349",
+      "size_bytes": 675104
+    },
+    {
+      "path": "backend/dataset/TrainsUK2/TrainsUK2_float_cpp_compression_result.csv",
+      "sha256": "78a93cc8f7a0bf1d5e23996b3253e68ee778c3d17f8b15bce24e49ca10771a8c",
+      "size_bytes": 200825
+    },
+    {
+      "path": "backend/dataset/TrainsUK2/TrainsUK2_float_java_compression_result.csv",
+      "sha256": "23c39706bc732cf0b36d8a65bd1cf2fa919425145f9e9d4f7237050458a4e858",
+      "size_bytes": 196065
+    },
+    {
+      "path": "backend/dataset/TrainsUK2/TrainsUK2_float_python_compression_result.csv",
+      "sha256": "39bd0051400704fc3f39218674f241a27841de1e8a88b9ed275c97f457312779",
+      "size_bytes": 8793
+    },
+    {
+      "path": "backend/dataset/TrainsUK2/TrainsUK2_int_cpp_compression_result.csv",
+      "sha256": "773bf3ab375e9af90ca65e1244e9d97b97facbb88b74a29011c3d6fc388ccc62",
+      "size_bytes": 87847
+    },
+    {
+      "path": "backend/dataset/TrainsUK2/TrainsUK2_int_java_compression_result.csv",
+      "sha256": "cf27402e3c2b59205ff99fdc93797196a28fe0f80c0f924d8ab649dded3e89d8",
+      "size_bytes": 85476
+    },
+    {
+      "path": "backend/dataset/TrainsUK2/TrainsUK2_int_python_compression_result.csv",
+      "sha256": "00e723803e85dea59cf0d862fd9ba53dca23a4ddf3473eedcf9f13e78ffd805b",
+      "size_bytes": 3988
+    },
+    {
+      "path": "backend/dataset/Uberlandia/Uberlandia_float_cpp_compression_result.csv",
+      "sha256": "77694a726f4377f40699afdc88ace777e6bf0d3cdcc8a1a5271724cab9ab61f1",
+      "size_bytes": 138037
+    },
+    {
+      "path": "backend/dataset/Uberlandia/Uberlandia_float_java_compression_result.csv",
+      "sha256": "c63e99743c36bfa8d1522662860f75aa4c761da217a59702ba6d930082fb6be5",
+      "size_bytes": 195114
+    },
+    {
+      "path": "backend/dataset/Uberlandia/Uberlandia_float_python_compression_result.csv",
+      "sha256": "7833b767666de0e0b2f994a02bedda9014eb2fa0299634085624034c3ebe164a",
+      "size_bytes": 6051
+    },
+    {
+      "path": "backend/dataset/Uberlandia/Uberlandia_int_cpp_compression_result.csv",
+      "sha256": "e5878d2af7f150be1f90cf5b47703ff6a075143c12a960537e4e2cb4b3684a14",
+      "size_bytes": 170075
+    },
+    {
+      "path": "backend/dataset/Uberlandia/Uberlandia_int_java_compression_result.csv",
+      "sha256": "d8aa4228630b24e67eb5ddf568c6041fd5361822ff2aaedfb5f7cb25e5825a61",
+      "size_bytes": 169946
+    },
+    {
+      "path": "backend/dataset/Uberlandia/Uberlandia_int_python_compression_result.csv",
+      "sha256": "85e99d937aef329a739c66476de79618ce1aee9d51fda97cd29cadaa90e53765",
+      "size_bytes": 81861
+    },
+    {
+      "path": "backend/dataset/Wins/Wins_float_cpp_compression_result.csv",
+      "sha256": "8b8b875f336b10f4fee7fac223a9092f5b5ba201f4d6ef5b9186d0932b721bcd",
+      "size_bytes": 1873999
+    },
+    {
+      "path": "backend/dataset/Wins/Wins_float_java_compression_result.csv",
+      "sha256": "be7e11bcd785cd1768f80833a365d05a8fb7704ab9f354fc9a8d9a76d7f23453",
+      "size_bytes": 1833893
+    },
+    {
+      "path": "backend/dataset/Wins/Wins_float_python_compression_result.csv",
+      "sha256": "e9b1a485f4d1cdca2c35eb6873acb18dba53c2ee3625ddf97254967706634c34",
+      "size_bytes": 1788984
+    },
+    {
+      "path": "backend/dataset/Wins/Wins_int_cpp_compression_result.csv",
+      "sha256": "62bc6504854fe91578a5e166b4f2b73f1352b768f1d86763acca700a42e3febb",
+      "size_bytes": 2022980
+    },
+    {
+      "path": "backend/dataset/Wins/Wins_int_java_compression_result.csv",
+      "sha256": "cf54baf1a65743f9c34174a447a83de2d8522d64352d7f2b3376a6448a5d5795",
+      "size_bytes": 2053903
+    },
+    {
+      "path": "backend/dataset/Wins/Wins_int_python_compression_result.csv",
+      "sha256": "eb0ec4bb7809800b4197af88389e51e9f3ef5263992edfd0c8533d96a347d1b7",
+      "size_bytes": 2066300
+    },
+    {
+      "path": "backend/dataset/YaleLanguages/YaleLanguages_float_cpp_compression_result.csv",
+      "sha256": "e9af231352060bbece862fccf5e5e314c027b7851b9c0d098c3bb90342e43ed6",
+      "size_bytes": 53072
+    },
+    {
+      "path": "backend/dataset/YaleLanguages/YaleLanguages_float_java_compression_result.csv",
+      "sha256": "9d2e21a163573eb349943c4f52341b9ffa1eda0ec6024408fc21b0df410cd3c2",
+      "size_bytes": 53166
+    },
+    {
+      "path": "backend/dataset/YaleLanguages/YaleLanguages_float_python_compression_result.csv",
+      "sha256": "b65bf9cefa0ca0f4d855173ea9a800f57a55e274d01101b0e5cc22c57f50f6f1",
+      "size_bytes": 5952
+    },
+    {
+      "path": "backend/dataset/YaleLanguages/YaleLanguages_int_cpp_compression_result.csv",
+      "sha256": "b5d7956c3126ff6d1b43a5b38cef6952995cd742ffc1fcecad83ebd05f96059b",
+      "size_bytes": 85604
+    },
+    {
+      "path": "backend/dataset/YaleLanguages/YaleLanguages_int_java_compression_result.csv",
+      "sha256": "307f9f84fef02ea73bfc2495956cdd3da809f21d4deb09aabf0dd4bf7ce05b39",
+      "size_bytes": 87891
+    },
+    {
+      "path": "backend/dataset/YaleLanguages/YaleLanguages_int_python_compression_result.csv",
+      "sha256": "041e1c290535faa69037053272b141906463dfbc6db6f70cef8569b0cfd5f689",
+      "size_bytes": 24426
+    },
+    {
+      "path": "backend/dataset/medium_posts/medium_posts_float_cpp_compression_result.csv",
+      "sha256": "225ab1a2788dd314f62d43caaa757087ad9d4f80539162f730b0b06c7430d2c0",
+      "size_bytes": 102
+    },
+    {
+      "path": "backend/dataset/medium_posts/medium_posts_float_java_compression_result.csv",
+      "sha256": "225ab1a2788dd314f62d43caaa757087ad9d4f80539162f730b0b06c7430d2c0",
+      "size_bytes": 102
+    },
+    {
+      "path": "backend/dataset/medium_posts/medium_posts_float_python_compression_result.csv",
+      "sha256": "225ab1a2788dd314f62d43caaa757087ad9d4f80539162f730b0b06c7430d2c0",
+      "size_bytes": 102
+    },
+    {
+      "path": "backend/dataset/medium_posts/medium_posts_int_cpp_compression_result.csv",
+      "sha256": "84bc7ea413e2e0628234c156dbd122643f8a011803ca7db1aef363df106d5eb0",
+      "size_bytes": 398
+    },
+    {
+      "path": "backend/dataset/medium_posts/medium_posts_int_java_compression_result.csv",
+      "sha256": "75a8d0d0136dba2e4720169d715a468d2b297f76f4f79f86f1aaa06dee91d613",
+      "size_bytes": 13728
+    },
+    {
+      "path": "backend/dataset/medium_posts/medium_posts_int_python_compression_result.csv",
+      "sha256": "32e88f5da4b21e4139d13f1a8288cd590ce47fe80d4420e3ff48738fce2ea08f",
+      "size_bytes": 155
+    },
+    {
+      "path": "backend/dataset/meteoblue/meteoblue_float_cpp_compression_result.csv",
+      "sha256": "9bd43f77d871354382bf32d2ba7a0a32df5b4eaf53f77c30863490041caec2d4",
+      "size_bytes": 1038305
+    },
+    {
+      "path": "backend/dataset/meteoblue/meteoblue_float_java_compression_result.csv",
+      "sha256": "d17720708b5605e2f94990ff4f3ca891cda8cdbbf245a451e5c4e81fb991a493",
+      "size_bytes": 1016830
+    },
+    {
+      "path": "backend/dataset/meteoblue/meteoblue_float_python_compression_result.csv",
+      "sha256": "bf27024c25f454aa0dd6bc37c224eea8065ee732cfd8f8c6e53348084637b7fb",
+      "size_bytes": 999793
+    },
+    {
+      "path": "backend/dataset/meteoblue/meteoblue_int_cpp_compression_result.csv",
+      "sha256": "225ab1a2788dd314f62d43caaa757087ad9d4f80539162f730b0b06c7430d2c0",
+      "size_bytes": 102
+    },
+    {
+      "path": "backend/dataset/meteoblue/meteoblue_int_java_compression_result.csv",
+      "sha256": "225ab1a2788dd314f62d43caaa757087ad9d4f80539162f730b0b06c7430d2c0",
+      "size_bytes": 102
+    },
+    {
+      "path": "backend/dataset/meteoblue/meteoblue_int_python_compression_result.csv",
+      "sha256": "7aae93648ea41f11dccfe38b2abe3a0439734eb8e4816973d9c3fed706fc3661",
+      "size_bytes": 153
+    },
+    {
+      "path": "backend/dataset/rating/rating_float_cpp_compression_result.csv",
+      "sha256": "a5d3df06633ee382945cae4aa8a39b471eadab769280baac2adf7bb802421357",
+      "size_bytes": 19010
+    },
+    {
+      "path": "backend/dataset/rating/rating_float_java_compression_result.csv",
+      "sha256": "99a5f00ff49d18ea40f43fc28c2dc19c605bf9723fcbce88062a8ee73fec0f19",
+      "size_bytes": 17560
+    },
+    {
+      "path": "backend/dataset/rating/rating_float_python_compression_result.csv",
+      "sha256": "1e2f5515ba1dd44e7dd94cc1d2c6e001b2a998f4d88ab7ee18b4723adeb93989",
+      "size_bytes": 21721
+    },
+    {
+      "path": "backend/dataset/rating/rating_int_cpp_compression_result.csv",
+      "sha256": "5beb990d62abe8710c96b438499041e53d3359c225a8f20f99440d7301b459ba",
+      "size_bytes": 36104
+    },
+    {
+      "path": "backend/dataset/rating/rating_int_java_compression_result.csv",
+      "sha256": "229448bf335b81e16900611bc7aee28378feb13cf579dfdb352f965bd7b98ad2",
+      "size_bytes": 34169
+    },
+    {
+      "path": "backend/dataset/rating/rating_int_python_compression_result.csv",
+      "sha256": "81e3c72aaa815cae82ffedd3ac99c28542e434c9c00507f5eab417ad37ab2b27",
+      "size_bytes": 39411
+    }
+  ],
+  "schema_version": 1,
+  "source_files": [
+    {
+      "path": "backend/myapp/paper_table3_snapshot.json",
+      "role": "paper_table3",
+      "sha256": "cfe4316a0e4cd9109f749ce7f8e0e4e66da9fbba4558dd4a92663a5bb632c66c",
+      "status": "tracked_clean"
+    },
+    {
+      "path": "benchmark/reference/datasets/ledger_public_compress_summary.json",
+      "role": "dataset_scope",
+      "sha256": "f3b6927bfe31eb2c7914ed7f7c247760ad9ad06692be8e0a2bb5c54b172bef61",
+      "status": "tracked_modified"
+    },
+    {
+      "path": "backend/dataset_result/catalog_public_items.json",
+      "role": "dataset_catalog",
+      "sha256": "01d818203612f3c96beaf0bd39fa5b6e895f6055f7bc8329c1e1635d5669a94d",
+      "status": "generated_or_ignored"
+    },
+    {
+      "path": "benchmark/reference/methods/method_operator_pipelines.json",
+      "role": "method_pipelines",
+      "sha256": "dd2bce587b2a2d4169a8e5b005b665cd4ca67af525334c46ad314363bf3987fe",
+      "status": "tracked_modified"
+    }
+  ]
+}

style.css

@@ -1,28 +1,9 @@
-body {
-	padding: 2rem;
-	font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
-	font-size: 16px;
-	margin-top: 0;
-}
-
-p {
-	color: rgb(107, 114, 128);
-	font-size: 15px;
-	margin-bottom: 10px;
-	margin-top: 5px;
-}
-
-.card {
-	max-width: 620px;
-	margin: 0 auto;
-	padding: 16px;
-	border: 1px solid lightgray;
-	border-radius: 16px;
-}
-
-.card p:last-child {
-	margin-bottom: 0;
-}
+:root{color-scheme:light;--bg:#fafbfb;--surface:#fff;--soft:#f1f5f4;--text:#162323;--muted:#536665;--line:#dce5e2;--accent:#116c59;--accent-soft:#e7f3ed;--hover:#f3f8f5;--shadow:0 16px 48px #142e2610;--radius:8px;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Arial,sans-serif}
+:root[data-theme=dark]{color-scheme:dark;--bg:#0f1719;--surface:#142024;--soft:#1a2a2d;--text:#edf5f2;--muted:#a4b9b4;--line:#30443f;--accent:#85d6b7;--accent-soft:#1a3c31;--hover:#1b302a;--shadow:none}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--text);font-size:14px;line-height:1.6}a{color:var(--accent);text-decoration:none}a:hover{text-decoration:underline}button,input,select{font:inherit}button{cursor:pointer}button:disabled{cursor:wait;opacity:.55}button,input,select,summary,a{outline-offset:4px}button:focus-visible,input:focus-visible,select:focus-visible,summary:focus-visible,a:focus-visible{outline:2px solid var(--accent)}button:active{transform:translateY(1px)}[hidden]{display:none!important}.skip-link{position:absolute;top:-80px;left:20px;z-index:3;background:var(--surface);padding:10px}.skip-link:focus{top:12px}.site-header{display:flex;align-items:center;justify-content:space-between;max-width:1380px;margin:auto;min-height:76px;padding:12px 32px;border-bottom:1px solid var(--line);gap:24px}.brand{display:flex;align-items:center;gap:12px;font-weight:650;color:var(--text);white-space:nowrap}.brand:hover{text-decoration:none}.brand-mark{display:grid;place-items:center;background:var(--accent);color:var(--bg);width:40px;height:40px;border-radius:var(--radius);font-size:13px;letter-spacing:.03em}.brand-sub{color:var(--muted);font-weight:400;margin-left:12px;padding-left:14px;border-left:1px solid var(--line)}.header-links{display:flex;gap:22px;align-items:center;white-space:nowrap}.quiet-button{background:transparent;border:1px solid var(--line);color:var(--text);padding:7px 12px;border-radius:var(--radius)}.quiet-button:hover{background:var(--soft)}main{max-width:1320px;margin:auto;padding:0 32px}.intro{text-align:center;padding:34px 0 24px}.eyebrow{color:var(--accent);font-size:11px;text-transform:uppercase;letter-spacing:.14em;font-weight:700;margin:0 0 12px}h1{font-size:clamp(26px,3.2vw,40px);font-weight:700;line-height:1.22;letter-spacing:-.03em;margin:0 0 14px}h2{font-size:21px;line-height:1.35;letter-spacing:-.02em;margin:0 0 4px}h3{font-size:17px;margin-top:28px}.intro-text{font-size:16px;color:var(--muted);margin:0 auto;max-width:700px}.snapshot{margin:12px 0 0;color:var(--muted);font-size:12px}.summary-strip{display:grid;grid-template-columns:repeat(4,1fr);border-block:1px solid var(--line);margin:0 0 22px;padding:17px 0}.summary-strip>div{text-align:center;border-right:1px solid var(--line)}.summary-strip>div:last-child{border:0}.summary-strip strong{display:block;font-size:25px;font-weight:650;line-height:1.2;font-variant-numeric:tabular-nums}.summary-strip span{font-size:12px;color:var(--muted)}.tabs{display:flex;gap:6px;border-bottom:1px solid var(--line);overflow-x:auto}.tab{padding:12px 22px;border:0;border-bottom:3px solid transparent;background:transparent;color:var(--muted);font-weight:600;white-space:nowrap}.tab:hover{color:var(--text);background:var(--soft)}.tab.active{color:var(--accent);border-bottom-color:var(--accent)}.filters{display:grid;grid-template-columns:1fr 1fr 1.1fr 1.5fr 1.7fr 1.2fr;gap:14px;background:var(--soft);padding:20px;border:1px solid var(--line);border-radius:var(--radius);margin:22px 0}label{display:flex;flex-direction:column;gap:6px;font-size:12px;font-weight:600;color:var(--muted)}select,input[type=search]{width:100%;height:39px;padding:0 10px;border:1px solid var(--line);border-radius:var(--radius);background:var(--surface);color:var(--text);min-width:0}input::placeholder{color:var(--muted)}select:disabled{opacity:.55}.toolbar{display:flex;justify-content:space-between;align-items:center;gap:18px;margin:20px 0 12px}.muted{color:var(--muted);font-size:13px;margin:0}.toolbar-actions{display:flex;gap:10px;white-space:nowrap}.primary-button{border:1px solid var(--accent);background:var(--accent);color:var(--bg);padding:8px 16px;border-radius:var(--radius);font-weight:600}.results-note{font-size:12px;color:var(--muted);padding:10px 0}.table-settings{display:flex;justify-content:space-between;align-items:center;padding:6px 0 14px;gap:12px;font-size:12px}.table-settings label,.column-options label{flex-direction:row;align-items:center;font-weight:400;gap:8px;color:var(--text)}input[type=checkbox]{accent-color:var(--accent);width:15px;height:15px}.table-settings details{position:relative}.table-settings summary{cursor:pointer;color:var(--muted)}.column-options{position:absolute;right:0;top:30px;z-index:2;min-width:230px;padding:14px;display:flex;flex-direction:column;gap:10px;background:var(--surface);border:1px solid var(--line);border-radius:var(--radius);box-shadow:var(--shadow)}.table-wrap{background:var(--surface);border:1px solid var(--line);border-radius:var(--radius);overflow:auto;max-height:620px}table{border-collapse:separate;border-spacing:0;width:100%;font-size:13px;white-space:nowrap}thead th{position:sticky;top:0;z-index:1;padding:14px 16px;background:var(--soft);text-align:right;border-bottom:1px solid var(--line);font-size:12px;color:var(--muted);font-weight:600}thead th:nth-child(1),thead th:nth-child(2){text-align:left}thead button{background:transparent;border:0;padding:0;color:inherit;font-weight:inherit;white-space:nowrap}thead button:hover{color:var(--accent)}tbody td{padding:13px 16px;border-bottom:1px solid var(--line);text-align:right;line-height:1.4}tbody tr:last-child td{border-bottom:0}tbody tr:hover{background:var(--hover)}tbody td:nth-child(1),tbody td:nth-child(2){text-align:left}.rank{color:var(--muted);width:50px}.method-button{border:0;background:transparent;color:var(--text);font-weight:650;padding:0;text-align:left}.method-button:hover{color:var(--accent);text-decoration:underline}.method-family{display:block;font-size:11px;color:var(--muted);margin-top:4px;font-weight:400}.numeric{font-family:"SFMono-Regular",Consolas,"Liberation Mono",monospace;font-variant-numeric:tabular-nums}.best{color:var(--accent);font-weight:700}.coverage{font-size:11px;border-radius:4px;padding:4px 7px;background:var(--soft);color:var(--muted)}.coverage.full{background:var(--accent-soft);color:var(--accent)}.loading-cell,.empty-cell{text-align:center!important;padding:54px;color:var(--muted);white-space:normal}.table-footer{display:flex;justify-content:space-between;color:var(--muted);font-size:11px;padding:12px 2px;gap:16px}.method-detail{margin-top:24px;padding:24px;background:var(--surface);border:1px solid var(--line);border-radius:var(--radius)}.detail-head{display:flex;justify-content:space-between;align-items:start;gap:16px}.detail-grid{display:grid;grid-template-columns:repeat(4,1fr);margin:20px 0;gap:16px}.detail-grid>div{border-left:2px solid var(--line);padding-left:14px}.detail-grid strong{display:block;font-size:21px;font-family:Consolas,monospace}.detail-grid span{font-size:11px;color:var(--muted)}.detail-table{max-height:330px;overflow:auto;border:1px solid var(--line);border-radius:var(--radius)}.detail-table td{font-size:12px}.source-code{font-family:Consolas,monospace;font-size:11px;overflow-wrap:anywhere}.text-view{max-width:1060px;margin:28px auto 42px}.text-view p{max-width:84ch}.definitions{display:grid;grid-template-columns:1fr 1fr;gap:22px 36px}.definitions dt{font-weight:650}.definitions dd{margin:6px 0 0;color:var(--muted);font-size:13px}.provenance-table{white-space:normal}.provenance-table th{width:170px;text-align:left;padding:10px 0;color:var(--muted)}.provenance-table td{text-align:left;padding:10px 12px;border-bottom:1px solid var(--line)}.notice{padding:14px 18px;border-left:3px solid var(--accent);background:var(--accent-soft);color:var(--text);font-size:13px;line-height:1.7}.error-message{background:var(--surface);padding:24px;margin:24px 0;border:1px solid var(--line);border-left:3px solid #b34938;color:var(--text)}.method-groups{display:grid;grid-template-columns:repeat(2,1fr);gap:0 40px}.method-group{padding:14px 0;border-top:1px solid var(--line)}.method-group h3{margin:0 0 12px}.method-group ul{display:flex;flex-wrap:wrap;list-style:none;padding:0;margin:0;gap:8px}.method-group li{background:var(--soft);padding:5px 9px;border-radius:4px;font-size:12px}.chart-controls{display:flex;gap:20px;align-items:end;margin:14px 0}.chart-controls label{width:250px}.chart{border:1px solid var(--line);border-radius:var(--radius);background:var(--surface);padding:16px;margin:10px 0 24px;overflow:auto}.chart svg{display:block;min-width:600px;max-width:100%;height:auto}.chart .gridline{stroke:var(--line);stroke-width:1}.chart .axis-label{fill:var(--muted);font-size:12px;font-family:Consolas,monospace}.chart .point{fill:var(--accent);opacity:.65;cursor:pointer;stroke:var(--surface);stroke-width:1.5}.chart .point:hover,.chart .point:focus{opacity:1;stroke:var(--text);stroke-width:2}.chart .point-label{fill:var(--text);font-size:12px}.chart .frontier{fill:none;stroke:var(--accent);stroke-width:1.5;stroke-dasharray:4 4}.chart-empty{text-align:center;padding:50px}.method-detail h3{margin-top:20px}footer{display:flex;justify-content:space-between;gap:20px;color:var(--muted);font-size:11px;padding:26px 0;border-top:1px solid var(--line);margin-top:36px}
+.filters{grid-template-columns:repeat(4,minmax(0,1fr))}.search-field{grid-column:span 2}
+.site-header{min-height:64px}.intro{padding:20px 0 16px}.eyebrow{margin-bottom:8px;font-size:10px}h1{font-size:clamp(25px,3vw,34px);margin-bottom:10px}.intro-text{font-size:14px}.snapshot{margin-top:8px}.summary-strip{padding:12px 0;margin-bottom:12px}.summary-strip strong{font-size:22px}.tab{padding:10px 20px}.filters{padding:16px;margin:16px 0;gap:10px}.filters select,.filters input{height:35px}.toolbar{margin:14px 0 8px}.results-note{padding:6px 0}.table-settings{padding-bottom:10px}
+@media(max-width:1100px){.filters{grid-template-columns:repeat(3,1fr)}.search-field{grid-column:1/-1}.brand-sub{display:none}.intro{padding-top:28px}.tab{padding-inline:18px}}
+@media(max-width:768px){main{padding:0 16px}.site-header{padding:12px 16px;min-height:64px}.header-links{gap:10px;font-size:12px}.brand{gap:8px;font-size:13px}.brand-mark{width:34px;height:34px}.intro{padding:28px 0 20px}.intro-text{font-size:14px}.filters{grid-template-columns:repeat(2,minmax(0,1fr));padding:14px;gap:12px}.summary-strip{padding:14px 0}.summary-strip strong{font-size:21px}.summary-strip span{display:block;font-size:10px;line-height:1.4;padding:5px}.toolbar{align-items:start;flex-direction:column}.toolbar-actions{width:100%;justify-content:space-between}.table-settings{align-items:start;font-size:11px}.table-settings label{max-width:65%}.table-footer{flex-direction:column;gap:4px}.tab{padding:10px 14px;font-size:13px}.definitions,.method-groups{grid-template-columns:1fr}.detail-grid{grid-template-columns:repeat(2,1fr)}.method-detail{padding:16px}.chart-controls{flex-direction:column;align-items:start}.chart-controls label{width:100%}.chart{padding:6px}.summary-strip>div{min-width:0}footer{flex-direction:column;gap:4px}.table-wrap{max-height:550px}.header-links>a{display:none}h2{font-size:19px}}
+@media(prefers-reduced-motion:reduce){*{scroll-behavior:auto!important;transition:none!important}}
+.intro{padding:16px 0 10px}.eyebrow{display:none}h1{font-size:clamp(24px,2.8vw,30px);margin-bottom:8px}.intro-text{font-size:13px}.snapshot{font-size:11px;margin-top:6px}.summary-strip{padding:10px 0}.summary-strip strong{font-size:20px}.filters{padding:12px;gap:8px}.toolbar{margin-top:12px;margin-bottom:4px}