app.js

import {FINAL160_SCOPE,FINAL160_INPUT_STATUS,applyFinal160Scope,filterFinal160Catalog,final160CoverageForFamily} from './final-scope.js?v=20261013-min128-v1';
import {WEIGHT_TENTHS,parseWeights,addRankingMetrics} from './ranking.js?v=20261011-support-matched-v1';
import {DEFAULT_PROFILE,profileLabel,defaultColumnVisible,metricAvailability,summarizeAvailability,visibleColumns,profileScopeText,aggregateTimedSubset,strictTimingMode} from './availability.js?v=20261013-overall-availability-v3';
const CPP_LATEST_VIEW_SHA256='5d2a8bb4fb5c38fbc4fa130a08b7608c7568f3959ef9dd2706f245862907f90f';
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; };
function timingMode(input) {
  return strictTimingMode(input);
}
function aggregateTime(input,key) {
  const mode=timingMode(input);
  if(mode==='unavailable')return null;
  if(mode==='dataset_mean')return mean(input.map(r=>r[key]));
  return input.reduce((sum,r)=>sum+r[key]*r.timing_column_count,0)/input.reduce((sum,r)=>sum+r.timing_column_count,0);
}
const timingLabel=mode=>({column_mean:'Equal-column arithmetic mean',dataset_mean:'Equal-dataset arithmetic mean',dataset_aggregate:'Dataset aggregate',unavailable:'Unavailable'}[mode]??'Unavailable');
const fmt = (v, digits=3) => number(v) === null ? 'Unavailable' : Number(v).toLocaleString('en-US',{maximumFractionDigits:digits,minimumFractionDigits:digits});
const countFmt = (v) => Number(v).toLocaleString('en-US');
const runtimeName = (v) => profileLabel(v,snapshot?.benchmark?.runtime_labels?.[v] || ({cpp:'C++',java:'Java',python:'Python','cpp-native166':'Native C++ · server 166','cpp-native192':'Native C++ · server 192'}[v] || v));
const runtimeHost = (v) => v==='cpp'?'multiple source environments; see per-dataset provenance':snapshot?.benchmark?.runtime_hosts?.[v] || ({'cpp-native166':'166','cpp-native192':'192'}[v] || 'source snapshot');
const THULAB_DATASET_PREFIX='https://huggingface.co/datasets/THULab/';
const requestedDataset=new URLSearchParams(location.search).get('dataset')?.trim()||'';
let requestedDatasetApplied=false;
const cols = [
  {key:'average_rank',label:'Average Rank ↓',digits:2,visible:true,defaultVisible:true,overallOnly:true},
  {key:'rank_coverage',label:'Rank coverage',digits:0,visible:true,defaultVisible:true,overallOnly:true},
  {key:'composite_score',label:'Composite score ↓',digits:4,visible:true,defaultVisible:true,overallOnly:true},
  {key:'compression_rate',label:'Average rate ↓',digits:4,visible:true,defaultVisible:true},
  {key:'overall_rate',label:'Overall rate ↓',digits:4,visible:false,defaultVisible:false},
  {key:'compression_time',label:'Compress ns/point ↓',digits:2,visible:true,defaultVisible:true},
  {key:'decompression_time',label:'Decompress ns/point ↓',digits:2,visible:true,defaultVisible:true},
  {key:'compression_time_timed_subset',label:'Compress ns/point · timed subset ↓',digits:2,visible:true,defaultVisible:true},
  {key:'decompression_time_timed_subset',label:'Decompress ns/point · timed subset ↓',digits:2,visible:true,defaultVisible:true},
  {key:'normalized_compression_time',label:'Normalized compress ↓',digits:4,visible:false,defaultVisible:false,overallOnly:true},
  {key:'normalized_decompression_time',label:'Normalized decompress ↓',digits:4,visible:false,defaultVisible:false,overallOnly:true},
  {key:'timing_column_count',label:'Measured columns',digits:0,visible:false,defaultVisible:false},
  {key:'compressed_bytes',label:'Compressed bytes',digits:0,visible:false,defaultVisible:false},
  {key:'original_bytes',label:'Original bytes',digits:0,visible:false,defaultVisible:false},
];
let snapshot, records=[], methods=new Map(), datasets=new Map(), currentRows=[], activeTab='overall';
let cppLatestView=null;
let referenceCatalog=null,referenceCatalogError=null,datasetCatalog=null,datasetCatalogError=null;
let operatorEffect=null,operatorEffectError=null;
let sort={key:'compression_rate',direction:1};
let selectedMethod=null;
const touchedColumns=new Set();
let legacyProfileRequested='';
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) {
  const sourceRuntime=r.runtime ?? r.implementation_language ?? snapshot.benchmark?.implementation_language ?? 'cpp';
  return { ...r,configuration:r.algorithm_variant??r.algorithm??r.method,method:r.algorithm_variant??r.algorithm??r.method,source_runtime:sourceRuntime,runtime:r.comparison_profile??sourceRuntime,
    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),
    eligible_column_set_sha256:r.eligible_column_set_sha256??'legacy_snapshot_unbound',measurement_status:r.measurement_status??'legacy_published_measurement',timing_profile_status:r.timing_profile_status??'source_snapshot_timing',binary_sha256:r.binary_sha256??'unbound' };
}
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 choices=new Map(),best=new Map();
    for(const r of result){const key=`${r.dataset}\0${r.family}`;if(!choices.has(key))choices.set(key,[]);choices.get(key).push(r);}
    for(const [key,rows] of choices){if(new Set(rows.map(r=>r.eligible_column_set_sha256)).size!==1)continue;for(const r of rows){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 coverageDatasetCount() { return new Set(filteredRecords(true).map(r=>r.dataset)).size; }
function populateFamilyControl() {
  const control=$('family');if(!control)return;
  const selected=control.value,scope=scopeKey(),runtime=$('runtime').value;
  const families=[...new Set(records.filter(record=>record.runtime===runtime&&record.scope===scope).map(record=>record.family))].sort((a,b)=>a.localeCompare(b));
  control.innerHTML='<option value="all">All method families</option>'+families.map(family=>`<option value="${escape(family)}">${escape(family)}</option>`).join('');
  control.value=families.includes(selected)?selected:'all';
}
function aggregate(input) {
  const groups=new Map();
  const exact=state().mode==='configuration',familiesByConfiguration=new Map();
  if(exact)for(const r of input){if(!familiesByConfiguration.has(r.method))familiesByConfiguration.set(r.method,new Set());familiesByConfiguration.get(r.method).add(r.family);}
  for(const r of input) { const key=exact?`${r.family}\0${r.method}`:r.method;if(!groups.has(key)) groups.set(key,[]); groups.get(key).push(r); }
  const totalDatasets=coverageDatasetCount();
  const rows=[];
  for(const [,source] of groups) {
    const configuration=source[0].method,method=exact&&familiesByConfiguration.get(configuration).size>1?`${source[0].family} · ${configuration}`:configuration;
    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;
    const timedSubset=aggregateTimedSubset(source);
    rows.push({method,family:source[0].family,runtime:source[0].runtime,compression_rate:mean(source.map(r=>r.compression_rate)),compression_time:aggregateTime(source,'compression_time'),decompression_time:aggregateTime(source,'decompression_time'),timing_column_count:source.reduce((sum,r)=>sum+(Number.isInteger(r.timing_column_count)?r.timing_column_count:0),0),timing_aggregation:timingMode(source),overall_rate:hasBytes?compressed/original:null,original_bytes:original,compressed_bytes:compressed,coverage:new Set(source.map(r=>r.dataset)).size,totalDatasets,source,...timedSubset});
  }
  const s=state();
  return addRankingMetrics(rows,parseWeights($('weights').value)).map(row=>row.normalization_reference_rows>=2?row:{...row,normalized_compression_time:null,normalized_decompression_time:null,composite_score:null}).filter(r=>(s.family==='all'||r.family===s.family)&&(!s.search||(s.mode==='family'?r.family:`${r.method} ${r.family}`).toLowerCase().includes(s.search))&&(!s.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 requestedColumns() {
  const profile=state().runtime;
  return cols.filter(column => touchedColumns.has(column.key)?column.visible:defaultColumnVisible(profile,column));
}
function syncColumnOptions() {
  for(const input of $('column-options').querySelectorAll('input')){
    const column=cols.find(item=>item.key===input.dataset.column);
    input.checked=touchedColumns.has(column.key)?column.visible:defaultColumnVisible(state().runtime,column);
  }
}
function metricCell(row,column) {
  if(column.key==='rank_coverage'&&number(row[column.key])!==null)return `${row.rank_coverage} / ${row.totalDatasets}`;
  if(number(row[column.key])!==null){
    const subset=['compression_time_timed_subset','decompression_time_timed_subset'].includes(column.key);
    return `${fmt(row[column.key],column.digits)}${subset?` <span class="metric-coverage" title="Timed subset coverage">${row.timing_subset_coverage} / ${row.timing_subset_denominator}</span>`:''}`;
  }
  const unavailable=metricAvailability(row,column.key);
  return `<span class="unavailable-value" title="${escape(unavailable.detail)}">${escape(unavailable.short)}</span>`;
}
function renderTable() {
  const eligibleColumns=cols.filter(c=>!c.overallOnly||activeTab==='overall');
  const visible=visibleColumns(eligibleColumns,currentRows,state().runtime,$('show-unavailable-columns').checked,touchedColumns);
  $('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>${activeTab==='overall'?'':`<span class="method-family">${escape(r.family)} · ${escape(runtimeName(r.runtime))}</span>`}</td>${visible.map(c=>`<td class="numeric ${!['compressed_bytes','original_bytes','rank_coverage','timing_column_count'].includes(c.key)&&number(r[c.key])!==null&&r[c.key]===minima[c.key]?'best':''}">${metricCell(r,c)}</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;
  const availability=summarizeAvailability(currentRows,requestedColumns());
  const visibleKeys=new Set(visible.map(column=>column.key)),hiddenLabels=requestedColumns().filter(column=>!visibleKeys.has(column.key)).map(column=>column.label.replace(' ↓',''));
  const timedSubsetRows=currentRows.filter(row=>number(row.compression_time_timed_subset)!==null&&number(row.decompression_time_timed_subset)!==null).length;
  $('availability-summary').textContent=`Availability: ${availability.parts.join(' · ')} · ${timedSubsetRows}/${availability.total} timed-subset rows (each cell shows timed datasets / current rate datasets).${availability.reasons.length?` ${availability.reasons.join('; ')}.`:''}${hiddenLabels.length&&!$('show-unavailable-columns').checked?` Hidden columns without complete row coverage: ${hiddenLabels.join(', ')}. Use “Show unavailable metric columns” to inspect their explicit reasons.`:''}`;
}
function refresh() {
  if(!snapshot)return;
  $('precision').disabled=$('dtype').value!=='float';
  const selectedDataset=state().dataset,selectedHasMeasurements=selectedDataset==='all'||records.some(r=>r.dataset===selectedDataset),columnCoverageNote='Compress and Decompress times use equal-column arithmetic means when every selected dataset has column timings. If a method has aggregate-only timings in the selection, its dataset ns/point values are averaged with equal weight per dataset. Timing basis is shown in method details and CSV. Column coverage may differ by method.';
  if(!selectedHasMeasurements) {
    $('results-note').textContent=FINAL160_INPUT_STATUS.pending_datasets.some(item=>item.dataset_id===selectedDataset)?'Corrected-input benchmark pending. Old incomplete input measurements are preserved in the historical snapshot and excluded from current rankings. ': `No published measurements are available for this catalog dataset. It is excluded from rankings rather than treated as zero. ${columnCoverageNote}`;
  } else 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. ${columnCoverageNote}`;
  } else $('results-note').textContent=`${state().mode==='family'?'Each family uses its lowest-rate measured configuration only when that dataset/family has one exact support set; ambiguous support sets are omitted. Configurations may differ across datasets; use Exact configuration for fixed parameters.':'Each row retains one exact configuration and its eligible support-set hash. Lower compression rates and lower ns/point are better.'} ${columnCoverageNote}`;
  currentRows=aggregate(filteredRecords(true));
  syncColumnOptions();
  const weights=parseWeights($('weights').value);
  const scoreAvailability=summarizeAvailability(currentRows,cols);
  const scoreStatus=!currentRows.length?'No candidate rows are visible; comparability is not inferred.':scoreAvailability.counts.composite_score===currentRows.length?'Composite scores use one complete exact dataset/support signature.':`Composite scores are withheld: ${scoreAvailability.reasons.length?scoreAvailability.reasons.join('; '):'a complete eligible normalization cohort is unavailable'}.`;
  $('score-note').textContent=`Score = ${weights[0].toFixed(1)} × average rate + ${weights[1].toFixed(1)} × normalized compress + ${weights[2].toFixed(1)} × normalized decompress. Lower is better. ${scoreStatus} Average Rank is computed only among rows with the same dataset and eligible aggregate-id support hash; ties share their average position. Missing, N/A, failed, and unlike-support results receive no rank.`;
  const s=state(),scope=scopeKey(),measuredCount=coverageDatasetCount(),ds=s.dataset==='all'?`all ${measuredCount} measured datasets`:datasetDisplayName(s.dataset);
  $('dataset-count').textContent=countFmt(measuredCount);$('dataset-count-label').textContent='measured datasets';
  $('method-count').textContent=countFmt(new Set(records.filter(record=>record.runtime===s.runtime&&record.scope===scope).map(record=>record.family)).size);
  const names={overall:'available numeric measurements',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`;
  $('profile-scope-note').textContent=profileScopeText({profile:s.runtime,measuredDatasets:measuredCount,catalogDatasets:datasetEntries().length})+(legacyProfileRequested?` The requested historical profile “${legacyProfileRequested}” is now included in the combined C++ view; this is not an environment-specific view.`:'');
  $('view-title').textContent=activeTab==='dataset'?`${s.dataset==='all'?'Dataset':datasetDisplayName(s.dataset)} leaderboard`:activeTab==='tradeoffs'?'Storage and execution trade-offs':'Overall leaderboard';
  const selectedEntry=s.dataset==='all'?null:datasets.get(s.dataset),selectedDatasetUrl=thulabDatasetUrl(selectedEntry),selectedBadge=$('selected-dataset-badge');
  selectedBadge.hidden=!selectedDatasetUrl;
  if(selectedDatasetUrl){selectedBadge.href=selectedDatasetUrl;selectedBadge.setAttribute('aria-label',`Open ${datasetDisplayName(s.dataset)} in the THULab Hugging Face organization`);selectedBadge.title='Open this dataset in the THULab Hugging Face organization.';}
  renderTable();
  if(activeTab==='tradeoffs')renderChart();
  if(selectedMethod)showMethod(selectedMethod,false);
}
function setTab(tab) {
  activeTab=['overall','dataset','tradeoffs','methods','operators','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','operators','about'].includes(activeTab);$('methods-view').hidden=activeTab!=='methods';$('operators-view').hidden=activeTab!=='operators';$('about-view').hidden=activeTab!=='about';$('chart-view').hidden=activeTab!=='tradeoffs';$('dataset-catalog-panel').hidden=activeTab!=='dataset';
  $('score-controls').hidden=activeTab!=='overall';
  for(const input of $('column-options').querySelectorAll('input'))input.parentElement.hidden=Boolean(cols.find(c=>c.key===input.dataset.column)?.overallOnly&&activeTab!=='overall');
  if(activeTab!=='overall'&&cols.find(c=>c.key===sort.key)?.overallOnly)sort={key:'compression_rate',direction:1};
  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';
  if(activeTab==='dataset')renderDatasetCatalog();
  updateUrlState();
  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));
  const supportDecisions=row.runtime==='cpp'?final160CoverageForFamily(cppLatestView.cpp.pair_ledger,row.family):[];
  const countSupport=predicate=>supportDecisions.filter(predicate).length;
  const supportNote=supportDecisions.length?`C++ test scope: ${supportDecisions.length} dataset identities; ${countSupport(item=>item.status==='numeric'&&item.scopes.includes('overall'))} numeric Overall, ${countSupport(item=>item.status==='numeric'&&!item.scopes.includes('overall'))} numeric type-specific only, ${countSupport(item=>item.status==='not_applicable')} not applicable, ${countSupport(item=>item.status==='unsupported')} unsupported, ${countSupport(item=>item.status==='replacement_input_pending')} corrected-input retests pending. Type-specific results are available through the data-type filter; they are not missing experiments.`:'';

  const strictCompress=metricCell(row,cols.find(column=>column.key==='compression_time')),strictDecompress=metricCell(row,cols.find(column=>column.key==='decompression_time')),subsetCompress=metricCell(row,cols.find(column=>column.key==='compression_time_timed_subset')),subsetDecompress=metricCell(row,cols.find(column=>column.key==='decompression_time_timed_subset'));
  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>${strictCompress}</strong><span>strict Compress ns/point</span></div><div><strong>${strictDecompress}</strong><span>strict Decompress ns/point</span></div><div><strong>${subsetCompress}</strong><span>Compress ns/point · timed subset</span></div><div><strong>${subsetDecompress}</strong><span>Decompress ns/point · timed subset</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>`:''}${supportNote?`<p class="notice">${escape(supportNote)}</p>`:''}<p class="muted">Strict timing average: ${escape(timingLabel(row.timing_aggregation))}. Timed-subset values are shown only when every included timing row has one exact source profile, host, and timing contract; they never enter strict composite scores. Dataset metrics below retain the winning row's source family, profile, and host.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Source family</th><th>Rate ↓</th><th>Compress ns/point ↓</th><th>Decompress ns/point ↓</th><th>Timing basis</th><th>Measurement evidence</th><th>Timing profile</th><th>Selected source profile / host</th><th>Runtime / binary</th><th>Support set</th><th>Original bytes</th><th>Compressed bytes</th><th>Dataset score ↓</th><th>Dataset Rank ↓</th><th>Rank candidates</th></tr></thead><tbody>${source.map(r=>`<tr><td>${escape(r.dataset)}</td><td>${escape(r.configuration)}</td><td>${escape(r.source_family??r.family)}</td><td class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${metricCell(r,cols.find(column=>column.key==='compression_time'))}</td><td class="numeric">${metricCell(r,cols.find(column=>column.key==='decompression_time'))}</td><td>${escape(timingLabel(r.timing_aggregation))}</td><td>${escape(r.measurement_status)}</td><td>${escape(r.timing_profile_status)}</td><td class="source-code">${escape(r.source_comparison_profile??r.runtime)} / ${escape(r.source_execution_host??'source snapshot')}</td><td class="source-code">${escape(r.source_runtime)} / ${escape(String(r.binary_sha256).slice(0,16))}</td><td class="source-code">${escape(String(r.eligible_column_set_sha256).slice(0,16))}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${metricCell(r,{key:'dataset_score',digits:4})}</td><td class="numeric">${metricCell(r,{key:'dataset_rank',digits:2})}</td><td class="numeric">${fmt(r.dataset_candidate_count,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 compressionMetric=metric.startsWith('compression'),subsetMetric=metric.includes('timed_subset');
  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)}, ${compressionMetric?'compression':'decompression'} ${fmt(r[metric],2)} ns per point${subsetMetric?`, timed subset ${r.timing_subset_coverage} of ${r.timing_subset_denominator} datasets`:''}" 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 | ${subsetMetric?`timed subset ${r.timing_subset_coverage}/${r.timing_subset_denominator}`:`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">${compressionMetric?'Compress':'Decompress'} ns/point${subsetMetric?' · timed subset':''} (log scale) ↓</text>`;
  $('chart').innerHTML=`<svg viewBox="0 0 ${width} ${height}" role="img" aria-label="Measured compression rates versus ${compressionMetric?'compression':'decompression'} cost${subsetMetric?' for a timing-admitted subset':''}">${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 weights=parseWeights($('weights').value);
  const columns=['position','method','comparison_profile','execution_host','scope','row_mode','selected_dataset','sort_metric','sort_direction','average_compression_rate','overall_compression_rate','compress_ns_per_point','decompress_ns_per_point','weight_a','weight_b','weight_c','normalized_compress','normalized_decompress','composite_score','average_rank','rank_dataset_coverage','normalization_reference_rows','compress_min','compress_max','decompress_min','decompress_max','normalization','rank_definition','dataset_coverage','datasets_in_scope','selected_configuration_by_dataset','source_profile_by_dataset','binary_sha256_by_dataset','eligible_column_set_sha256_by_dataset','measurement_status_by_dataset','timing_profile_status_by_dataset','timing_column_count','timing_aggregation','timed_subset_compress_ns_per_point','timed_subset_decompress_ns_per_point','timed_subset_dataset_coverage','timed_subset_dataset_denominator','timed_subset_status','timed_subset_source_profiles','timed_subset_source_hosts','selected_source_family_by_dataset','selected_source_comparison_profile_by_dataset','selected_source_host_by_dataset','strict_timing_reason','composite_reason','final_dataset_scope','input_version_gate','pending_replacement_datasets'];
  const body=currentRows.map((r,i)=>[i+1,r.method,r.runtime,runtimeHost(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,...weights.map(w=>w.toFixed(1)),r.normalized_compression_time,r.normalized_decompression_time,r.composite_score,r.average_rank,r.rank_coverage,r.normalization_reference_rows,r.encode_min,r.encode_max,r.decode_min,r.decode_max,'min-max over all measured rows in selected language/scope/row-mode before search and visibility filters','mean per-dataset composite-score fractional rank; per-dataset min-max times',r.coverage,r.totalDatasets,JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.configuration]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.source_runtime]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.binary_sha256]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.eligible_column_set_sha256]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.measurement_status]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.timing_profile_status]))),r.timing_column_count,r.timing_aggregation,r.compression_time_timed_subset,r.decompression_time_timed_subset,r.timing_subset_coverage,r.timing_subset_denominator,r.timing_subset_status,JSON.stringify(r.timing_subset_source_profiles),JSON.stringify(r.timing_subset_hosts),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.source_family??s.family]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.source_comparison_profile??s.runtime]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.source_execution_host??'source snapshot']))),metricAvailability(r,'compression_time').code,metricAvailability(r,'composite_score').code,FINAL160_INPUT_STATUS.scope_id,'not_quarantined_by_current_input_audit',JSON.stringify(FINAL160_INPUT_STATUS.pending_datasets.map(item=>item.dataset_id))].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 safeHttpUrl(value) {
  try { const url=new URL(String(value));return ['http:','https:'].includes(url.protocol)?url.href:null; } catch { return null; }
}
function thulabDatasetUrl(entry) {
  const url=safeHttpUrl(entry?.dataset_url);
  return url?.startsWith(THULAB_DATASET_PREFIX)?url:null;
}
function thulabDatasetBadge(entry,key=datasetKey(entry)) {
  const url=thulabDatasetUrl(entry);if(!url)return '';
  return `<a class="thulab-dataset-badge" href="${escape(url)}" target="_blank" rel="noopener noreferrer" aria-label="Open ${escape(key)} in the THULab Hugging Face organization" title="Open this dataset in the THULab Hugging Face organization."><span aria-hidden="true">🏆</span> THULab hosted ↗</a>`;
}
function publicNote(value) {
  const note=typeof value==='string'?value.trim():'';
  return /(?:\/Users\/|[A-Za-z]:\\|file:\/\/|codex:\/\/threads\/|\.pptx\b)/i.test(note)?'':note;
}
function publicText(value,fallback='') { const text=publicNote(value);return text||fallback; }
function referenceMap() {
  return new Map((referenceCatalog?.references||[]).map(reference=>[String(reference.id),reference]));
}
function resolvedReferences(ids) {
  const byId=referenceMap();
  return [...new Set(Array.isArray(ids)?ids.map(String):[])].map(id=>byId.get(id)).filter(Boolean);
}
function referenceSearchText(ids) {
  return resolvedReferences(ids).map(reference=>`${reference.id??''} ${reference.citation??''} ${reference.kind??''}`).join(' ');
}
function renderReferences(ids) {
  const references=resolvedReferences(ids);
  if(!references.length)return '<p class="reference-empty">No external reference is listed for this entry.</p>';
  return `<div class="documentation-references"><strong>References</strong><ul>${references.map(reference=>{const url=safeHttpUrl(reference.url),citation=escape(reference.citation||reference.id||'Reference');const meta=[reference.id,reference.source_slide?`Presentation Notes · slide ${reference.source_slide}`:'Additional official source'].filter(Boolean).map(escape).join(' · ');return `<li>${url?`<a href="${escape(url)}" target="_blank" rel="noopener noreferrer">${citation}</a>`:`<span>${citation}</span>`}${meta?`<small>${meta}</small>`:''}</li>`;}).join('')}</ul></div>`;
}
function familyConfigurations() {
  const grouped=new Map();
  for(const record of records){if(!grouped.has(record.family))grouped.set(record.family,new Set());grouped.get(record.family).add(record.configuration);}
  return new Map([...grouped].map(([family,names])=>[family,[...names].sort((a,b)=>a.localeCompare(b))]));
}
function catalogMethod(family) {
  const entries=referenceCatalog?.methods||[];
  return entries.find(entry=>entry.family===family)||entries.find(entry=>String(entry.family).toLowerCase()===family.toLowerCase())||null;
}
function renderMethodDocumentation() {
  const container=$('method-catalog'),status=$('method-doc-status');
  if(!container||!status)return;
  if(referenceCatalogError){status.textContent='Method documentation could not be loaded.';container.innerHTML=`<p class="documentation-error">${escape(referenceCatalogError.message)}</p>`;return;}
  if(!referenceCatalog){status.textContent='Loading method documentation…';container.innerHTML='';return;}
  const configurations=familyConfigurations(),query=$('method-doc-search').value.trim().toLowerCase();
  const families=[...configurations.keys()].sort((a,b)=>a.localeCompare(b));
  const rows=families.map(family=>{const entry=catalogMethod(family)||{},names=configurations.get(family),note=publicNote(entry.notes),search=[family,entry.display_name,entry.description,note,...names,referenceSearchText(entry.reference_ids)].join(' ').toLowerCase();return {family,entry,names,note,search};}).filter(row=>!query||row.search.includes(query));
  const described=families.filter(family=>catalogMethod(family)?.description).length;
  status.textContent=`${rows.length} of ${families.length} measured method families shown · ${described} descriptions available`;
  container.innerHTML=rows.length?rows.map(({family,entry,names,note})=>{const display=entry.display_name||family;return `<article class="documentation-card"><div class="documentation-card-head"><div><h3>${escape(display)}</h3>${display!==family?`<span class="documentation-code">${escape(family)}</span>`:''}</div><span class="documentation-count">${names.length} configuration${names.length===1?'':'s'}</span></div><p class="documentation-description">${escape(entry.description||'A reference description is not available for this measured family.')}</p>${note?`<p class="documentation-note">${escape(note)}</p>`:''}${renderReferences(entry.reference_ids)}<details class="configuration-details"><summary>Published configurations (${names.length})</summary><ul>${names.map(name=>`<li>${escape(name)}</li>`).join('')}</ul></details></article>`;}).join(''):'<p class="documentation-empty">No method documentation matches this search.</p>';
}
function renderOperatorEffect() {
  const status=$('operator-effect-status'),body=$('operator-effect-table')?.querySelector('tbody');if(!status||!body)return;
  if(operatorEffectError){status.textContent='Verified byte-effect results could not be loaded.';body.innerHTML=`<tr><td colspan="7" class="empty-cell">${escape(operatorEffectError.message)}</td></tr>`;return;}
  if(!operatorEffect){status.textContent='Loading verified byte effects…';return;}
  const rows=operatorEffect.rows||[],audit=operatorEffect.audit||{};
  status.textContent=`Historical input-version diagnostic. Current-scope, corrected-input operator replacement is pending. ${rows.length} omitted operators · ${countFmt(audit.admitted_ok_row_count||0)} admitted rows from the exact ${countFmt(audit.input_row_count||0)}-row union · timing unavailable`;
  body.innerHTML=rows.length?rows.map(row=>`<tr><td>${escape(row.operator)}</td><td class="numeric">${fmt(row.mean_omission_to_baseline_ratio,3)}×</td><td class="numeric ${number(row.mean_byte_change_percent)>0?'operator-effect-cost':'operator-effect-saving'}">${number(row.mean_byte_change_percent)>0?'+':''}${fmt(row.mean_byte_change_percent,1)}%</td><td class="numeric">${fmt(row.mean_baseline_to_original_ratio,3)}</td><td class="numeric">${fmt(row.mean_omission_to_original_ratio,3)}</td><td class="numeric"><span class="coverage">${countFmt(row.dataset_count)}</span></td><td class="numeric">${countFmt(row.row_count)}</td></tr>`).join(''):'<tr><td colspan="7" class="empty-cell">No admitted matched-omission rows.</td></tr>';
}
async function loadOperatorEffect() {
  try {
    const response=await fetch('./operator-byte-effect-summary.json?v=20261011-byte-effect-v1',{cache:'no-cache'});if(!response.ok)throw new Error(`Operator byte-effect request returned ${response.status}.`);
    const value=await response.json();if(value?.schema!=='compressionbenchmark-operator-byte-effect-summary-v1'||value?.status!=='accepted'||value?.timing?.status!=='unavailable'||!Array.isArray(value.rows))throw new Error('Operator byte-effect summary has an invalid schema.');operatorEffect=value;
  } catch(error) { operatorEffectError=error instanceof Error?error:new Error('Operator byte-effect summary is unavailable.'); }
  renderOperatorEffect();
}
function renderOperatorDocumentation() {
  const container=$('operator-catalog'),status=$('operator-doc-status');
  if(!container||!status)return;
  if(referenceCatalogError){status.textContent='Operator documentation could not be loaded.';container.innerHTML=`<p class="documentation-error">${escape(referenceCatalogError.message)}</p>`;return;}
  if(!referenceCatalog){status.textContent='Loading operator documentation…';container.innerHTML='';return;}
  const query=$('operator-doc-search').value.trim().toLowerCase(),all=referenceCatalog.operators||[];
  const rows=all.map(operator=>{const implementations=Array.isArray(operator.implementations)?operator.implementations:[];const familySearch=[operator.id,operator.name,operator.name_en,operator.name_zh,operator.group,operator.description,referenceSearchText(operator.reference_ids)].join(' ').toLowerCase();const matchingImplementations=query&&!familySearch.includes(query)?implementations.filter(entry=>operatorImplementationSearch(entry).includes(query)):implementations;return {operator,implementations:matchingImplementations,familyMatch:!query||familySearch.includes(query)};}).filter(row=>row.familyMatch||row.implementations.length);
  const groups=new Map();
  for(const row of rows){const group=row.operator.group||'Other';if(!groups.has(group))groups.set(group,[]);groups.get(group).push(row);}
  const shownEntries=new Set(rows.flatMap(row=>row.implementations.map(entry=>entry.id||`${row.operator.id}:${entry.name||entry.name_en||''}`))).size,totalEntries=new Set(all.flatMap(operator=>(operator.implementations||[]).map(entry=>entry.id||`${operator.id}:${entry.name||entry.name_en||''}`))).size;
  status.textContent=`${rows.length} of ${all.length} operator families shown · ${shownEntries} of ${totalEntries} directory entries shown`;
  renderOperatorSummary();
  container.innerHTML=rows.length?[...groups].map(([group,groupRows])=>`<section class="operator-group"><h3>${escape(publicText(group,'Other'))}</h3><div class="documentation-grid">${groupRows.map(({operator,implementations})=>renderOperatorCard(operator,implementations)).join('')}</div></section>`).join(''):'<p class="documentation-empty">No operator family or implementation entry matches this search.</p>';
}
function operatorImplementationSearch(entry) {
  return [entry.id,entry.name,entry.name_en,entry.name_zh,entry.layer,entry.description,entry.inputs,entry.outputs,entry.example,entry.status,referenceSearchText(entry.reference_ids)].join(' ').toLowerCase();
}
function renderOperatorSummary() {
  const target=$('operator-summary');if(!target||!referenceCatalog)return;
  const summary=referenceCatalog.operator_summary||{},families=number(summary.family_count??summary.operator_family_count)??(referenceCatalog.operators||[]).length;
  const entries=number(summary.entry_count??summary.directory_entry_count??summary.implementation_count)??(referenceCatalog.operators||[]).reduce((sum,item)=>sum+(item.implementations?.length||0),0);
  const parts=[['Families',families],['Directory entries',entries],['Mechanisms',summary.mechanism_count],['Configurations',summary.configuration_count],['Compositions',summary.composition_count],['Adapters',summary.adapter_count]];
  target.innerHTML=parts.filter(([,value])=>number(value)!==null).map(([label,value])=>`<div><strong>${countFmt(value)}</strong><span>${escape(label)}</span></div>`).join('');
}
function renderOperatorCard(operator,implementations) {
  const allEntries=Array.isArray(operator.implementations)?operator.implementations:[],name=publicText(operator.name_en??operator.name,operator.id||'Operator family'),nativeName=publicText(operator.name_zh),description=publicText(operator.description,'Description not available.');
  return `<article class="documentation-card operator-card"><div class="documentation-card-head"><div><h4>${escape(name)}</h4>${nativeName&&nativeName!==name?`<span class="documentation-native-name">${escape(nativeName)}</span>`:''}${operator.id&&operator.id!==name?`<span class="documentation-code">${escape(publicText(operator.id))}</span>`:''}</div><span class="documentation-count">${implementations.length}${implementations.length!==allEntries.length?` / ${allEntries.length}`:''} entries</span></div><p class="documentation-description">${escape(description)}</p>${renderReferences(operator.reference_ids)}${implementations.length?`<details class="implementation-details"><summary>Implementation directory (${implementations.length}${implementations.length!==allEntries.length?` matching of ${allEntries.length}`:''})</summary><div class="implementation-list">${implementations.map(renderOperatorImplementation).join('')}</div></details>`:'<p class="reference-empty">No implementation entry matches this search.</p>'}</article>`;
}
function renderOperatorImplementation(entry) {
  const name=publicText(entry.name_en??entry.name,entry.id||'Implementation entry'),nativeName=publicText(entry.name_zh),layer=publicText(entry.layer,'entry'),fields=[['Principle',entry.description],['Input',entry.inputs],['Output',entry.outputs],['Example',entry.example],['Status',entry.status]].filter(([,value])=>publicText(value));
  return `<article class="implementation-entry"><div class="implementation-head"><div><strong>${escape(name)}</strong>${nativeName&&nativeName!==name?`<span class="documentation-native-name">${escape(nativeName)}</span>`:''}${entry.id?`<span class="documentation-code">${escape(publicText(entry.id))}</span>`:''}</div><span class="implementation-layer">${escape(layer)}</span></div>${fields.length?`<dl>${fields.map(([label,value])=>`<div><dt>${escape(label)}</dt><dd>${escape(publicText(value))}</dd></div>`).join('')}</dl>`:''}${entry.reference_ids?.length?renderReferences(entry.reference_ids):''}</article>`;
}
function renderDocumentationViews() { renderMethodDocumentation();renderOperatorDocumentation();renderOperatorEffect(); }
async function loadReferenceCatalog() {
  try {
    const response=await fetch('./reference-catalog.json?v=20261013-corrected-five-v1',{cache:'no-cache'});
    if(!response.ok)throw new Error(`Reference catalog request returned ${response.status}.`);
    const catalog=await response.json();
    if(!catalog||!Array.isArray(catalog.methods)||!Array.isArray(catalog.operators)||!Array.isArray(catalog.references))throw new Error('Reference catalog has an invalid schema.');
    referenceCatalog=catalog;
  } catch(error) { referenceCatalogError=error instanceof Error?error:new Error('Reference catalog is unavailable.'); }
  if(snapshot)renderDocumentationViews();
}
function datasetKey(entry) { return String(entry?.key??entry?.dataset??''); }
function datasetDisplayName(key) { const entry=datasets.get(key);return entry?.label&&entry.label!==key?`${entry.label} (${key})`:key; }
function datasetEntries() {
  const source=Array.isArray(datasetCatalog?.datasets)&&datasetCatalog.datasets.length?datasetCatalog.datasets:[...(snapshot?.datasets||[])];
  const unique=new Map();for(const entry of source){const key=datasetKey(entry);if(key&&FINAL160_SCOPE.datasets.includes(key))unique.set(key,entry);}return [...unique.values()];
}
function datasetCategory(entry) { return String(entry.category_label??entry.category??'Other'); }
function datasetSearchText(entry) { return [datasetKey(entry),entry.label,entry.category,entry.category_label,entry.source,entry.dataset_url,thulabDatasetUrl(entry)?'THULab Hugging Face hosted':''].join(' ').toLowerCase(); }
function humanBytes(value) { const amount=number(value);if(amount===null)return '';const units=['B','KB','MB','GB','TB'];let scaled=amount,index=0;while(scaled>=1000&&index<units.length-1){scaled/=1000;index++;}return `${scaled.toLocaleString('en-US',{maximumFractionDigits:index?1:0})} ${units[index]}`; }
function populateDatasetControls() {
  if(!snapshot)return;
  const entries=datasetEntries(),selected=$('dataset').value||'all',measured=new Set(records.map(record=>record.dataset)),groups=new Map();
  for(const entry of entries){const group=datasetCategory(entry);if(!groups.has(group))groups.set(group,[]);groups.get(group).push(entry);datasets.set(datasetKey(entry),entry);}
  $('dataset').innerHTML='<option value="all">All measured datasets</option>'+[...groups].map(([group,items])=>`<optgroup label="${escape(group)}">${items.sort((a,b)=>datasetKey(a).localeCompare(datasetKey(b))).map(entry=>{const key=datasetKey(entry),label=entry.label&&entry.label!==key?`${entry.label} (${key})`:key;return `<option value="${escape(key)}">${thulabDatasetUrl(entry)?'🏆 ':''}${escape(label)}${measured.has(key)?'':' · No published measurements'}</option>`;}).join('')}</optgroup>`).join('');
  const requestedIsValid=!requestedDatasetApplied&&requestedDataset&&[...$('dataset').options].some(option=>option.value===requestedDataset);
  $('dataset').value=requestedIsValid?requestedDataset:[...$('dataset').options].some(option=>option.value===selected)?selected:'all';
  if(requestedIsValid)requestedDatasetApplied=true;
  const groupSelect=$('dataset-group-filter'),previousGroup=groupSelect.value||'all',categories=[...groups.keys()];
  groupSelect.innerHTML='<option value="all">All groups</option>'+categories.map(group=>`<option value="${escape(group)}">${escape(group)} (${groups.get(group).length})</option>`).join('');
  groupSelect.value=categories.includes(previousGroup)?previousGroup:'all';
}
function renderDatasetCatalog() {
  const container=$('dataset-catalog'),status=$('dataset-catalog-status');if(!container||!status||!snapshot)return;
  const all=datasetEntries(),query=$('dataset-catalog-search').value.trim().toLowerCase(),group=$('dataset-group-filter').value,measured=new Set(records.map(record=>record.dataset));
  const visible=all.filter(entry=>(group==='all'||datasetCategory(entry)===group)&&(!query||datasetSearchText(entry).includes(query))),groups=new Map();
  for(const entry of visible){const category=datasetCategory(entry);if(!groups.has(category))groups.set(category,[]);groups.get(category).push(entry);}
  const measuredVisible=visible.filter(entry=>measured.has(datasetKey(entry))).length,thulabVisible=visible.filter(entry=>thulabDatasetUrl(entry)).length;
  status.textContent=`${visible.length} of ${all.length} datasets shown · ${thulabVisible} THULab-hosted · ${measuredVisible} shown entries have published measurements · rankings use ${measured.size} measured datasets`;
  if(datasetCatalogError&&!all.length){container.innerHTML=`<p class="documentation-error">${escape(datasetCatalogError.message)}</p>`;return;}
  container.innerHTML=visible.length?[...groups].map(([category,entries])=>`<section class="dataset-category"><h3>${escape(category)} <span>${entries.length}</span></h3><div class="dataset-list">${entries.sort((a,b)=>datasetKey(a).localeCompare(datasetKey(b))).map(entry=>renderDatasetEntry(entry,measured.has(datasetKey(entry)))).join('')}</div></section>`).join(''):'<p class="documentation-empty">No dataset matches this search and group filter.</p>';
  for(const button of container.querySelectorAll('[data-dataset-key]'))button.addEventListener('click',()=>{$('dataset').value=button.dataset.datasetKey;updateUrlState();refresh();renderDatasetCatalog();$('leaderboard-wrap').scrollIntoView({block:'nearest'});});
}
function renderDatasetEntry(entry,isMeasured) {
  const key=datasetKey(entry),label=publicText(entry.label,key),rows=number(entry.row_count),payload=humanBytes(entry.size_bytes),metadata=[rows===0?'Empty dataset':rows!==null?`${countFmt(rows)} rows`:'',number(entry.column_count)!==null?`${countFmt(entry.column_count)} columns`:'',number(entry.numeric_column_count)!==null?`${countFmt(entry.numeric_column_count)} numeric`:'',payload?`${payload} numeric payload`:'' ].filter(Boolean),sourceUrl=safeHttpUrl(entry.source_url),datasetUrl=safeHttpUrl(entry.dataset_url),thulabUrl=thulabDatasetUrl(entry),source=publicText(entry.source,'Source'),snapshotDiff=entry.published_result_row_count_matches_catalog===false;
  return `<article class="dataset-entry ${isMeasured?'measured':'pending'} ${state().dataset===key?'selected':''}"><button type="button" data-dataset-key="${escape(key)}"><span><strong>${escape(label)}</strong>${label!==key?`<small>${escape(key)}</small>`:''}</span><span class="dataset-state">${isMeasured?'Measured':'No published measurements'}</span></button>${thulabUrl?`<div class="dataset-affiliations">${thulabDatasetBadge(entry,key)}</div>`:''}${metadata.length?`<p>${metadata.map(escape).join(' · ')}</p>`:''}${entry.current_input_issue?`<p class="dataset-snapshot-note">Corrected-input retest pending: ${escape(entry.current_input_issue)}</p>`:''}${snapshotDiff?'<p class="dataset-snapshot-note">Published measurements use an earlier prepared snapshot.</p>':''}<div class="dataset-links">${sourceUrl?`<a href="${escape(sourceUrl)}" target="_blank" rel="noopener noreferrer">${escape(source)} ↗</a>`:entry.source?`<span class="dataset-source">${escape(source)}</span>`:''}${datasetUrl&&datasetUrl!==sourceUrl&&!thulabUrl?`<a href="${escape(datasetUrl)}" target="_blank" rel="noopener noreferrer">Dataset files ↗</a>`:''}</div></article>`;
}
async function loadDatasetCatalog() {
  try {
    const response=await fetch('./dataset-catalog.json?v=20261013-corrected-five-v1',{cache:'no-cache'});if(!response.ok)throw new Error(`Dataset catalog request returned ${response.status}.`);
    const catalog=await response.json();if(!catalog||!Array.isArray(catalog.datasets)||!catalog.summary)throw new Error('Dataset catalog has an invalid schema.');datasetCatalog=filterFinal160Catalog(catalog);
  } catch(error) { datasetCatalogError=error instanceof Error?error:new Error('Dataset catalog is unavailable.'); }
  if(snapshot){populateDatasetControls();renderDatasetCatalog();renderAbout();}
}
function renderAbout() {
  const b=snapshot.benchmark||{},s=snapshot.source||{},c=snapshot.coverage||{};
  const notes=['The active test scope contains 137 dataset identities after uniformly excluding mean numerical-sequence lengths below 128; timestamp-only medium_posts is separately ineligible because it has no admitted scientific numeric payload. The previous 160 identity scope and all old inputs/results are preserved in the archive. FreshRetailNet-LT and Kaggle Web Traffic old incomplete inputs are quarantined pending new accepted results. Historical downloads retain the original scope and versions.',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 catalogCount=number(datasetCatalog?.summary?.dataset_count??c.catalog_dataset_count)??datasetEntries().length,measuredCount=number(datasetCatalog?.summary?.published_result_dataset_count??datasetCatalog?.summary?.published_measurement_dataset_count??datasetCatalog?.summary?.measured_dataset_count??c.measured_dataset_count)??new Set(records.map(r=>r.dataset)).size;
  const terminal=c.native86_terminal_coverage||{};
  const info={ 'Snapshot exported':snapshot.exported_at||s.exported_at||'Unavailable in snapshot','Dataset catalog':`${catalogCount} datasets; ${measuredCount} currently have published measurements and participate in rankings`,'Historical 164-dataset Native85 terminal matrix':terminal.expected_pair_count?`${terminal.observed_pair_count} / ${terminal.expected_pair_count} dataset-method pairs; ${terminal.numeric_pair_count??0} contain published numeric aggregates, ${terminal.not_applicable_pair_count??0} are explicit N/A, ${terminal.problem_pair_count??0} ended with a failure status`:'See manifest and terminal coverage download','Dataset scope generated':s.generated_at||'Unavailable in snapshot', 'Source checkout':s.git_commit||'Unavailable in snapshot','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 unavailable in this exported result snapshot.','Lossless evidence':b.roundtrip_evidence||'Lossless-design method filter from the source project; per-run round-trip verification is unavailable 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>`:''}`;
}
function decodeCompactRecord(row,index) {
  const t=snapshot.record_tables;
  return {_compact_index:index,dataset:t.datasets[row[0]],scope:t.scopes[row[1]],runtime:t.runtimes[row[2]],comparison_profile:t.comparison_profiles[row[3]],family:t.families[row[4]],method:t.configurations[row[5]],algorithm_variant:t.configurations[row[5]],compression_rate:row[6],compression_time_ns_per_point:row[7],decompression_time_ns_per_point:row[8],original_size_bytes:row[9],compressed_size_bytes:row[10],timing_column_count:row[11],timing_aggregation:t.timing_aggregations[row[12]],eligible_column_set_sha256:t.support_sets[row[13]],measurement_status:t.measurement_statuses[row[14]],timing_profile_status:t.timing_statuses[row[15]],binary_sha256:t.binary_hashes[row[16]]};
}
function applyCppLatestView() {
  if(!cppLatestView||cppLatestView.schema!=='compressionbenchmark-cpp-latest-view-v1'||cppLatestView.status!=='built_from_frozen_published_admitted_sources')throw new Error('The combined C++ selection sidecar has an invalid schema or status.');
  const compact=snapshot.compact_records;if(!Array.isArray(compact))throw new Error('The SHA-bound compact record table is missing.');
  if(cppLatestView.baseline?.compact_record_count!==compact.length)throw new Error('The combined C++ sidecar compact-record count does not match the frozen payload.');
  if(cppLatestView.baseline?.data_sha256!==snapshot.source_data_sha256)throw new Error('The combined C++ sidecar source data hash does not match the frozen payload.');
  const selectors=cppLatestView.selectors;if(!Array.isArray(selectors)||selectors.join('\0')!=='cpp\0java\0python')throw new Error('The combined view must expose exactly C++, Java, and Python.');
  const selected=cppLatestView.cpp?.selected_rows;if(!Array.isArray(selected))throw new Error('The combined C++ selected-row index is missing.');
  const seen=new Set(),cpp=[];
  for(const item of selected){
    const index=item?.raw_compact_index;
    if(!Number.isInteger(index)||index<0||index>=compact.length||seen.has(index))throw new Error('The combined C++ selected-row indices are invalid or duplicated.');
    seen.add(index);
    const decoded=decodeCompactRecord(compact[index],index);
    if(['java','python'].includes(decoded.comparison_profile)||decoded.comparison_profile!==item.source_comparison_profile||decoded.runtime!==item.source_runtime||decoded.family!==item.source_family)throw new Error(`Combined C++ provenance mismatch at compact row ${index}.`);
    if(typeof item.canonical_family!=='string'||!item.canonical_family||typeof item.source_host!=='string'||!item.source_host)throw new Error(`Combined C++ identity metadata is incomplete at compact row ${index}.`);
    const decodedTimingAdmitted=/^timing_admitted_/i.test(String(decoded.timing_profile_status??''));
    if(Boolean(item.timing_admitted)!==decodedTimingAdmitted||item.pair_status!=='numeric')throw new Error(`Combined C++ admission metadata mismatch at compact row ${index}.`);
    cpp.push({...decoded,comparison_profile:'cpp',family:item.canonical_family,source_family:item.source_family,source_comparison_profile:item.source_comparison_profile,source_runtime:item.source_runtime,source_execution_host:item.source_host,selection_authority:item.authority,pair_status:item.pair_status});
  }
  const ledger=cppLatestView.cpp?.pair_ledger;if(!Array.isArray(ledger))throw new Error('The combined C++ pair ledger is missing.');
  for(const decision of ledger)if(decision.status!=='numeric'&&Array.isArray(decision.selected_raw_indices)&&decision.selected_raw_indices.length)throw new Error('A terminal N/A or unsupported decision attempts to fall back to an older numeric row.');
  const expectedTiming=new Set(cppLatestView.cpp?.timing_subset?.selected_raw_indices||[]),actualTiming=new Set(selected.filter(item=>item.timing_admitted).map(item=>item.raw_compact_index));
  if(expectedTiming.size!==actualTiming.size||[...expectedTiming].some(index=>!actualTiming.has(index)))throw new Error('The combined C++ admitted-timing index does not match selected-row metadata.');
  const imported=compact.map(decodeCompactRecord).filter(row=>['java','python'].includes(row.comparison_profile)).map(row=>{
    const publishedHost=snapshot.benchmark?.runtime_hosts?.[row.comparison_profile];
    return {...row,source_family:row.family,source_comparison_profile:row.comparison_profile,source_runtime:row.runtime,source_execution_host:typeof publishedHost==='string'?publishedHost.trim():''};
  });
  snapshot.dataset_results=[...cpp,...imported];delete snapshot.compact_records;
}
function init() {
  applyCppLatestView();
  snapshot=applyFinal160Scope(snapshot);
  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 runtimeOrder=['cpp','java','python'];
  const runtimes=[...new Set(records.map(r=>r.runtime))].sort((a,b)=>{const ai=runtimeOrder.indexOf(a),bi=runtimeOrder.indexOf(b);return (ai<0?runtimeOrder.length:ai)-(bi<0?runtimeOrder.length:bi)||a.localeCompare(b);});
  $('runtime').innerHTML=runtimes.map(r=>`<option value="${escape(r)}">${escape(runtimeName(r))}</option>`).join('');
  const requestedProfile=new URLSearchParams(location.search).get('profile');
  if(runtimes.includes(requestedProfile))$('runtime').value=requestedProfile;
  else if(requestedProfile&&requestedProfile!=='cpp'){legacyProfileRequested=requestedProfile;$('runtime').value='cpp';}
  else $('runtime').value=runtimes.includes(DEFAULT_PROFILE)?DEFAULT_PROFILE:runtimes[0];
  populateDatasetControls();
  populateFamilyControl();
  $('runtime-count').textContent=runtimes.length;$('record-count').textContent=countFmt(new Set(records.map(r=>`${r.runtime}\0${r.family}\0${r.method}`)).size);
  const exported=snapshot.exported_at||snapshot.source?.exported_at||'unavailable';$('snapshot').textContent=`Result snapshot exported · ${String(exported).replace('T',' ').slice(0,19)}${exported==='unavailable'?'':' UTC'}`;$('footer-snapshot').textContent=`Source inputs documented in the manifest`;
  $('column-options').innerHTML=cols.map(c=>`<label><input type="checkbox" data-column="${c.key}" ${defaultColumnVisible($('runtime').value,c)?'checked':''}>${escape(c.label)}</label>`).join('');
  $('weights').innerHTML=WEIGHT_TENTHS.map(w=>`<option value="${w.join(',')}" ${w.join(',')==='4,3,3'?'selected':''}>a = ${(w[0]/10).toFixed(1)} · b = ${(w[1]/10).toFixed(1)} · c = ${(w[2]/10).toFixed(1)}</option>`).join('');
  $('weights').addEventListener('change',refresh);
  for(const input of $('column-options').querySelectorAll('input'))input.addEventListener('change',()=>{const column=cols.find(c=>c.key===input.dataset.column);touchedColumns.add(column.key);column.visible=input.checked;renderTable();});
  $('show-unavailable-columns').addEventListener('change',renderTable);
  $('runtime').addEventListener('change',()=>{legacyProfileRequested='';populateFamilyControl();refresh();updateUrlState();});
  for(const id of ['dtype','precision'])$(id).addEventListener('change',()=>{populateFamilyControl();refresh();});
  for(const id of ['family','row-mode','complete-only'])$(id).addEventListener('change',refresh);$('dataset').addEventListener('change',()=>{updateUrlState();refresh();if(activeTab==='dataset')renderDatasetCatalog();});$('search').addEventListener('input',refresh);$('chart-metric').addEventListener('change',renderChart);$('download').addEventListener('click',csv);
  $('reset').addEventListener('click',()=>{$('runtime').value=runtimes.includes(DEFAULT_PROFILE)?DEFAULT_PROFILE:runtimes[0];$('dtype').value='overall';$('precision').value='all';populateFamilyControl();$('dataset').value='all';$('row-mode').value='family';$('search').value='';$('family').value='all';$('weights').value='4,3,3';$('complete-only').checked=false;$('show-unavailable-columns').checked=false;touchedColumns.clear();for(const column of cols)column.visible=column.defaultVisible;legacyProfileRequested='';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',()=>setTab(tab.dataset.tab));
  $('method-doc-search').addEventListener('input',renderMethodDocumentation);$('operator-doc-search').addEventListener('input',renderOperatorDocumentation);$('dataset-catalog-search').addEventListener('input',renderDatasetCatalog);$('dataset-group-filter').addEventListener('change',renderDatasetCatalog);
  renderAbout();renderDocumentationViews();renderDatasetCatalog();setTab(location.hash.slice(1)||(requestedDataset&&$('dataset').value===requestedDataset?'dataset':'overall'));
  document.documentElement.dataset.ready='true';
}
function updateUrlState() {
  const url=new URL(location.href);url.hash=activeTab;
  const profile=$('runtime')?.value;if(profile)url.searchParams.set('profile',profile);
  const selected=$('dataset')?.value;
  if(selected&&selected!=='all')url.searchParams.set('dataset',selected);else url.searchParams.delete('dataset');
  history.replaceState(null,'',`${url.pathname}${url.search}${url.hash}`);
}
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();
void loadReferenceCatalog();
void loadOperatorEffect();
void loadDatasetCatalog();
async function sha256Hex(buffer){const digest=await crypto.subtle.digest('SHA-256',buffer);return [...new Uint8Array(digest)].map(byte=>byte.toString(16).padStart(2,'0')).join('');}
try {
  const [snapshotResponse,sidecarResponse]=await Promise.all([fetch('./ui-data.json?v=20261013-cpp-latest-v1',{cache:'no-cache'}),fetch('./cpp-latest-view.json?v=20261013-cpp-latest-v1',{cache:'no-cache'})]);
  if(!snapshotResponse.ok)throw new Error(`Snapshot request returned ${snapshotResponse.status}`);if(!sidecarResponse.ok)throw new Error(`Combined C++ sidecar request returned ${sidecarResponse.status}`);
  const [snapshotBuffer,sidecarBuffer]=await Promise.all([snapshotResponse.arrayBuffer(),sidecarResponse.arrayBuffer()]);
  const sidecarSha=await sha256Hex(sidecarBuffer);if(sidecarSha!==CPP_LATEST_VIEW_SHA256)throw new Error('The combined C++ sidecar does not match the independently reviewed release selection.');
  const sidecarValue=JSON.parse(new TextDecoder().decode(sidecarBuffer));
  const snapshotSha=await sha256Hex(snapshotBuffer);if(snapshotSha!==sidecarValue?.baseline?.ui_data_sha256)throw new Error('The combined C++ sidecar is not bound to this exact UI snapshot.');
  snapshot=JSON.parse(new TextDecoder().decode(snapshotBuffer));cppLatestView=sidecarValue;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>';}