Align final operator implementations and 169-dataset catalog

README.md

@@ -21,10 +21,11 @@ From the source project checkout, regenerate the snapshots with:
 
 ```bash
 python3 deploy/huggingface-compressionbenchmark/export_results.py
+python3 deploy/huggingface-compressionbenchmark/apply_dataset_scope.py
 python3 deploy/huggingface-compressionbenchmark/build_ui_payload.py
 ```
 
-Publish `README.md`, `index.html`, `style.css`, `app.js`, `ranking.js`, `reference-catalog.json`, `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. The reference catalog is an independent documentation payload and does not affect leaderboard measurements.
+Publish `README.md`, `index.html`, `style.css`, `app.js`, `ranking.js`, `reference-catalog.json`, `dataset-catalog.json`, `data.json`, `ui-data.json`, `manifest.json`, `export_results.py`, `apply_dataset_scope.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. The reference and dataset catalogs are independent documentation payloads and do not create benchmark measurements.
 
 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.
 
@@ -34,10 +35,11 @@ Only measurements in the authoritative current project scope are exported. Missi
 - 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
+- Searchable 169-dataset catalog grouped into six source categories, with explicit measurement availability and source links
 - Overall composite score and average dataset Rank, with 36 valid positive one-decimal weight combinations
-- Searchable Methods and Operators documentation with presentation-note references and external source links
+- Searchable Methods documentation and a 30-family operator catalog with 102 implementation-directory entries, references, I/O contracts, examples, and status
 
-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 dataset catalog and the measured benchmark scope are separate. All 169 catalog entries are searchable and selectable, while only datasets with published measurements participate in the leaderboard; pending entries show **No published measurements** and are never converted to zero-valued results. The default family view selects the best measured compression-rate configuration independently for each measured dataset. Switch to **Exact configuration** to hold a configuration fixed. Runtime results stay separate.
 
 The Overall score is `a × average rate + b × normalized average encode time + c × normalized average decode time`. Time normalization is linear min–max across all eligible rows in the selected runtime, scope and row mode; an equal-time range normalizes to zero. Search, family and coverage filters only hide rows and never change the reference. Average Rank averages per-dataset composite-score ranks with dataset-local time normalization and fractional ties. Missing results are omitted. Coverage and candidate counts can differ across datasets; method details expose dataset scores, ranks and candidate counts. CSV downloads include weights, normalization bounds and rank coverage. The default weights are `a=0.4, b=0.3, c=0.3`.
 

app.js

@@ -1,4 +1,4 @@
-import {WEIGHT_TENTHS,parseWeights,addRankingMetrics} from './ranking.js?v=20261008-rank-v1';
+import {WEIGHT_TENTHS,parseWeights,addRankingMetrics} from './ranking.js?v=20261008-scope169-v1';
 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;
@@ -20,7 +20,7 @@ const cols = [
   {key:'original_bytes',label:'Original bytes',digits:0,visible:false},
 ];
 let snapshot, records=[], methods=new Map(), datasets=new Map(), currentRows=[], activeTab='overall';
-let referenceCatalog=null,referenceCatalogError=null;
+let referenceCatalog=null,referenceCatalogError=null,datasetCatalog=null,datasetCatalogError=null;
 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});
@@ -72,7 +72,10 @@ function renderTable() {
 function refresh() {
   if(!snapshot)return;
   $('precision').disabled=$('dtype').value!=='float';
-  if(scopeKey()==='float'&&!records.some(r=>r.scope==='float')) {
+  const selectedDataset=state().dataset,selectedHasMeasurements=selectedDataset==='all'||records.some(r=>r.dataset===selectedDataset);
+  if(!selectedHasMeasurements) {
+    $('results-note').textContent='No published measurements are available for this catalog dataset. It is excluded from rankings rather than treated as zero.';
+  } 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.';
@@ -83,10 +86,10 @@ function refresh() {
   $('audit-notice').textContent=audit?'DBP measurement audit: '+audit.timing+' '+audit.storage+' Float end-to-end losslessness is not established. See method details.':'';
   const weights=parseWeights($('weights').value);
   $('score-note').textContent=`Score = ${weights[0].toFixed(1)} × average rate + ${weights[1].toFixed(1)} × normalized encode + ${weights[2].toFixed(1)} × normalized decode. Lower is better. Time normalization: (time − minimum) / (maximum − minimum), across all measured rows in this runtime, scope and row mode. Search and visibility filters keep the reference fixed. Average Rank: mean of per-dataset score ranks with dataset-local time normalization; ties share their average position. Missing results are omitted. Dataset candidate counts differ, so compare rank coverage and inspect method details.`;
-  const s=state(),scope=scopeKey(),ds=s.dataset==='all'?'all measured datasets':s.dataset;
+  const s=state(),scope=scopeKey(),measuredCount=new Set(records.map(r=>r.dataset)).size,ds=s.dataset==='all'?`all ${measuredCount} measured datasets`:datasetDisplayName(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';
+  $('view-title').textContent=activeTab==='dataset'?`${s.dataset==='all'?'Dataset':datasetDisplayName(s.dataset)} leaderboard`:activeTab==='tradeoffs'?'Storage and execution trade-offs':'Overall leaderboard';
   renderTable();
   if(activeTab==='tradeoffs')renderChart();
   if(selectedMethod)showMethod(selectedMethod,false);
@@ -94,12 +97,13 @@ function refresh() {
 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';
+  $('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();
   refresh();
 }
 function showMethod(method,focus=false) {
@@ -139,8 +143,9 @@ function safeHttpUrl(value) {
 }
 function publicNote(value) {
   const note=typeof value==='string'?value.trim():'';
-  return /(?:\/Users\/|[A-Za-z]:\\|file:\/\/|\.pptx\b)/i.test(note)?'':note;
+  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]));
 }
@@ -183,16 +188,36 @@ function renderOperatorDocumentation() {
   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 visible=all.filter(operator=>!query||[operator.id,operator.name,operator.group,operator.description,referenceSearchText(operator.reference_ids)].join(' ').toLowerCase().includes(query));
+  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 operator of visible){const group=operator.group||'Other';if(!groups.has(group))groups.set(group,[]);groups.get(group).push(operator);}
-  status.textContent=`${visible.length} of ${all.length} operators shown`;
-  container.innerHTML=visible.length?[...groups].sort((a,b)=>a[0].localeCompare(b[0])).map(([group,operators])=>`<section class="operator-group"><h3>${escape(group)}</h3><div class="documentation-grid">${operators.sort((a,b)=>String(a.name).localeCompare(String(b.name))).map(operator=>`<article class="documentation-card operator-card"><div class="documentation-card-head"><div><h4>${escape(operator.name||operator.id)}</h4>${operator.id&&operator.id!==operator.name?`<span class="documentation-code">${escape(operator.id)}</span>`:''}</div></div><p class="documentation-description">${escape(operator.description||'Description not available.')}</p>${renderReferences(operator.reference_ids)}</article>`).join('')}</div></section>`).join(''):'<p class="documentation-empty">No operator documentation matches this search.</p>';
+  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(); }
 async function loadReferenceCatalog() {
   try {
-    const response=await fetch('./reference-catalog.json?v=20261008-docs-v1',{cache:'no-cache'});
+    const response=await fetch('./reference-catalog.json?v=20261008-scope169-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.');
@@ -200,6 +225,49 @@ async function loadReferenceCatalog() {
   } 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)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].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)}">${escape(label)}${measured.has(key)?'':' · No published measurements'}</option>`;}).join('')}</optgroup>`).join('');
+  $('dataset').value=[...$('dataset').options].some(option=>option.value===selected)?selected:'all';
+  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';
+  const catalogCount=number(datasetCatalog?.summary?.dataset_count??snapshot.coverage?.catalog_dataset_count)??entries.length,measuredCount=number(datasetCatalog?.summary?.published_result_dataset_count??datasetCatalog?.summary?.published_measurement_dataset_count??datasetCatalog?.summary?.measured_dataset_count??snapshot.coverage?.measured_dataset_count)??measured.size;
+  $('dataset-count').textContent=countFmt(catalogCount);$('dataset-count-label').textContent=`datasets in catalog · ${countFmt(measuredCount)} measured`;
+}
+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;
+  status.textContent=`${visible.length} of ${all.length} datasets shown · ${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;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),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>${metadata.length?`<p>${metadata.map(escape).join(' · ')}</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?`<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=20261008-scope169-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=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=[b.scope_note,b.aggregation_note,b.selection_note,...(b.notes||[]),...(b.measurement_boundaries||[])].filter(Boolean);
@@ -207,7 +275,8 @@ function renderAbout() {
   for(const [method,audit] of Object.entries(b.method_audits||{}))$('methodology').innerHTML+=`<div class="notice"><strong>${escape(method)} measurement audit · ${escape(audit.audited_at)}</strong>${[audit.implementation,audit.timing,audit.storage,audit.roundtrip,audit.comparison].map(n=>`<p>${escape(n)}</p>`).join('')}</div>`;
   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.'};
+  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 info={ 'Snapshot exported':snapshot.exported_at||s.exported_at||'Not reported','Dataset catalog':`${catalogCount} datasets; ${measuredCount} currently have published measurements and participate in rankings`,'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>`:''}`;
 }
 function init() {
@@ -218,9 +287,9 @@ function init() {
   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('');
+  populateDatasetControls();
   $('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);
+  $('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('');
   $('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('');
@@ -229,8 +298,8 @@ function init() {
   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';$('weights').value='4,3,3';$('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);});
-  $('method-doc-search').addEventListener('input',renderMethodDocumentation);$('operator-doc-search').addEventListener('input',renderOperatorDocumentation);
-  renderAbout();renderDocumentationViews();setTab(location.hash.slice(1)||'overall');
+  $('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)||'overall');
   document.documentElement.dataset.ready='true';
 }
 function setupTheme() {
@@ -242,5 +311,6 @@ function setupTheme() {
 }
 setupTheme();
 void loadReferenceCatalog();
-try { const response=await fetch('./ui-data.json?v=20261008-rank-v1',{cache:'no-cache'});if(!response.ok)throw new Error(`Snapshot request returned ${response.status}`);snapshot=await response.json();init(); }
+void loadDatasetCatalog();
+try { const response=await fetch('./ui-data.json?v=20261008-scope169-v1',{cache:'no-cache'});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>';}

apply_dataset_scope.py

@@ -0,0 +1,107 @@
+"""Apply the public dataset catalog to an existing measured snapshot.
+
+This is a scope filter, not a benchmark runner: retained individual measurements
+are copied unchanged, excluded measurements are removed, and aggregates are
+recomputed. Catalog-only datasets receive no fabricated measurement rows.
+"""
+from __future__ import annotations
+
+from collections import defaultdict
+import datetime
+import hashlib
+import json
+from pathlib import Path
+
+from export_results import _aggregate_rows
+
+ROOT = Path(__file__).resolve().parent
+
+
+def sha(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def apply() -> None:
+    catalog_path = ROOT / "dataset-catalog.json"
+    catalog = json.loads(catalog_path.read_text())
+    data_path = ROOT / "data.json"
+    data = json.loads(data_path.read_text())
+    allowed = {d["key"] for d in catalog["datasets"]}
+    if len(allowed) != 169 or len(catalog["datasets"]) != 169:
+        raise ValueError("The reviewed public catalog must contain 169 unique datasets")
+    excluded = {d["key"] for d in catalog.get("excluded", [])}
+    if allowed & excluded:
+        raise ValueError("Excluded datasets are present in the public catalog")
+    old_rows = data["dataset_results"]
+    rows = [r for r in old_rows if r["dataset"] in allowed]
+    if not rows:
+        raise ValueError("The snapshot has no measurements in the reviewed scope")
+    measured = {r["dataset"] for r in rows}
+    old_sha = sha(data_path)
+    data["dataset_results"] = rows
+    data["datasets"] = [{**d, "has_published_measurements": d["key"] in measured}
+                        for d in catalog["datasets"]]
+    configurations = defaultdict(list)
+    families = defaultdict(list)
+    for original in rows:
+        r = dict(original)
+        # Preserve the exporter's 8-byte-equivalent denominator, including
+        # historical rows whose source byte totals are not divisible by eight.
+        r["point_count"] = r["original_size_bytes"] / 8.0
+        r["compression_time_ns"] = r["compression_time_ns_per_point"] * r["point_count"]
+        r["decompression_time_ns"] = r["decompression_time_ns_per_point"] * r["point_count"]
+        configurations[r["runtime"], r["scope"], r["family"], r["method"]].append(r)
+        if r["is_best_rate_in_family"]:
+            families[r["runtime"], r["scope"], r["family"]].append(r)
+    data["configuration_aggregates"] = [
+        _aggregate_rows(rs, runtime=rt, scope_key=sc, family=fa, method=me, algorithm_variant=me)
+        for (rt, sc, fa, me), rs in sorted(configurations.items())]
+    data["family_best_aggregates"] = [
+        _aggregate_rows(rs, runtime=rt, scope_key=sc, family=fa, method=fa, algorithm_variant=None)
+        for (rt, sc, fa), rs in sorted(families.items())]
+    method_keys = {(r["method"], r["family"]) for r in rows}
+    data["methods"] = [m for m in data["methods"] if (m["name"], m["family"]) in method_keys]
+    data["report_availability"] = [r for r in data["report_availability"] if r["dataset"] in allowed]
+    # Retire the unrelated older paper aggregation instead of presenting it as
+    # evidence for the new catalog scope.
+    data.pop("paper_table3", None)
+    data["dataset_overview"] = {
+        "dataset_count": 169, "measured_dataset_count": len(measured),
+        "total_rows": sum(d.get("row_count") or 0 for d in catalog["datasets"]),
+        "total_rows_available_dataset_count": sum(d.get("row_count") is not None for d in catalog["datasets"]),
+        "provenance_note": "Dataset catalog statistics follow the reviewed 169-dataset scope. Compression metrics use only published measurement rows."}
+    benchmark = data["benchmark"]
+    benchmark.pop("paper_result_selection", None)
+    benchmark["metric_definitions"] = {k: v for k, v in benchmark["metric_definitions"].items() if not k.startswith("paper_")}
+    for field in ("notes", "measurement_boundaries"):
+        benchmark[field] = [s for s in benchmark.get(field, []) if "paper" not in s.lower()]
+    benchmark["scope_note"] = f"The dataset catalog contains 169 reviewed datasets (18 legacy + 151 THULab). Published measurement rows currently cover {len(measured)} of them. Catalog inclusion does not imply completed experiments or full-column coverage."
+    benchmark["publication_note"] = "The new Native86 evaluation is a separate, incomplete experiment. Its partial outputs are not mixed with this published multi-runtime snapshot."
+    source = data["source"]
+    source["source_files"] = [s for s in source["source_files"] if s.get("role") not in ("paper_table3", "dataset_scope", "dataset_catalog")]
+    source["source_files"].append({"role": "reviewed_dataset_catalog", "path": "dataset-catalog.json", "sha256": sha(catalog_path), "status": "reviewed_public_catalog"})
+    source["result_csv_files_used"] = [s for s in source["result_csv_files_used"] if len(Path(s["path"]).parts) >= 3 and Path(s["path"]).parts[2] in allowed]
+    source["scope_applied_at"] = datetime.datetime.now(datetime.timezone.utc).isoformat()
+    source.setdefault("scope_input_snapshot_sha256", old_sha)
+    source["scope_catalog_sha256"] = sha(catalog_path)
+    coverage = data["coverage"]
+    coverage.update(dataset_count=169, catalog_dataset_count=169, measured_dataset_count=len(measured),
+                    dataset_result_row_count=len(rows), configuration_aggregate_row_count=len(data["configuration_aggregates"]),
+                    family_best_aggregate_row_count=len(data["family_best_aggregates"]),
+                    method_family_count=len({r["family"] for r in rows}), method_configuration_count=len({r["method"] for r in rows}),
+                    runtime_configuration_count=len({(r["runtime"], r["method"]) for r in rows}),
+                    source_report_file_count=len(source["result_csv_files_used"]), paper_leaderboard_row_count=0,
+                    excluded_datasets=sorted(excluded | set(coverage.get("excluded_datasets", []))))
+    data["dataset_summary"] = {**catalog["summary"], "published_measurement_dataset_count": len(measured)}
+    data_path.write_text(json.dumps(data, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n")
+    manifest_path = ROOT / "manifest.json"
+    manifest = json.loads(manifest_path.read_text())
+    manifest.update(counts=coverage, data_sha256=sha(data_path), source_files=source["source_files"],
+                    result_csv_files=source["result_csv_files_used"], dataset_catalog_sha256=sha(catalog_path))
+    manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True) + "\n")
+    print(json.dumps({"catalog_datasets": 169, "measured_datasets": len(measured), "retained_rows": len(rows),
+                      "removed_rows": len(old_rows) - len(rows), "data_sha256": sha(data_path)}))
+
+
+if __name__ == "__main__":
+    apply()

build_ui_payload.py

@@ -21,7 +21,9 @@ def build() -> None:
                         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 = {key: data[key] for key in ('schema_version','benchmark','coverage','datasets','methods','scopes','source')}
+    if 'dataset_summary' in data:
+        payload['dataset_summary'] = data['dataset_summary']
     payload['exported_at'] = datetime.datetime.now(datetime.timezone.utc).isoformat()
     payload['source_data_sha256'] = hashlib.sha256(source.read_bytes()).hexdigest()
     payload['record_tables'] = tables

data.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:47ddcf459b1eedd8b1dcf89d07ee544e10b527e6da24c64f81de18628b324454
-size 28048937
+oid sha256:7618054cc2699fd855f673bfd41f7f5b94ee466028043bc669e457ead1984f63
+size 34661683

index.html

@@ -6,8 +6,8 @@
   <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?v=20261008-docs-v1">
-  <script src="app.js?v=20261008-docs-v1" type="module"></script>
+  <link rel="stylesheet" href="style.css?v=20261008-scope169-v1">
+  <script src="app.js?v=20261008-scope169-v1" type="module"></script>
 </head>
 <body>
   <a class="skip-link" href="#content">Skip to results</a>
@@ -19,11 +19,11 @@
     <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="intro-text">Browse the 169-dataset catalog and compare published storage, encoding, and decoding measurements.</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="dataset-count">…</strong><span id="dataset-count-label">datasets in catalog</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>
@@ -38,6 +38,17 @@
     </nav>
     <div id="load-error" class="error-message" role="alert" hidden></div>
     <section id="results-view" aria-label="Compression results">
+      <section id="dataset-catalog-panel" class="dataset-catalog-panel" aria-labelledby="dataset-catalog-title" hidden>
+        <div class="dataset-catalog-head">
+          <div><h2 id="dataset-catalog-title">Dataset catalog</h2><p class="muted">Browse all cataloged datasets. Entries without published measurements remain visible but are excluded from rankings.</p></div>
+          <div class="dataset-catalog-controls">
+            <label>Dataset group<select id="dataset-group-filter"><option value="all">All groups</option></select></label>
+            <label>Search datasets<input id="dataset-catalog-search" type="search" placeholder="Name, category, or source" autocomplete="off"></label>
+          </div>
+        </div>
+        <p id="dataset-catalog-status" class="documentation-status" aria-live="polite">Loading dataset catalog…</p>
+        <div id="dataset-catalog" class="dataset-catalog"></div>
+      </section>
       <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>
@@ -82,10 +93,11 @@
     </section>
     <section id="operators-view" class="text-view documentation-view" hidden>
       <div class="documentation-head">
-        <div><h2>Operators</h2><p class="muted">Reusable transforms and coding primitives that appear across time-series compression methods.</p></div>
-        <label class="documentation-search">Search operators<input id="operator-doc-search" type="search" placeholder="Name, group, description, or reference" autocomplete="off"></label>
+        <div><h2>Operators</h2><p class="muted">Thirty operator families organize a 102-entry implementation directory. Directory entries include mechanisms, configurations, compositions, and adapters; they are not 102 distinct atomic operators.</p></div>
+        <label class="documentation-search">Search operators<input id="operator-doc-search" type="search" placeholder="Family, A-ID, implementation, I/O, or reference" autocomplete="off"></label>
       </div>
-      <p class="reference-source">References from the presentation Notes (slides 2–3). External links open in a new tab.</p>
+      <div id="operator-summary" class="operator-summary" aria-label="Operator catalog summary"></div>
+      <p class="reference-source">The family split follows the final operator registry; references include the presentation Notes and official implementation sources. STOP, Concat, and continuous Split are control or graph operations and are excluded from the 30-family count. Split (columnize) remains family 29. External links open in a new tab.</p>
       <p id="operator-doc-status" class="documentation-status" aria-live="polite">Loading operator documentation…</p>
       <div id="operator-catalog" class="operator-groups"></div>
     </section>

manifest.json

@@ -1,17 +1,22 @@
 {
   "counts": {
+    "catalog_dataset_count": 169,
     "configuration_aggregate_row_count": 4653,
-    "dataset_count": 19,
-    "dataset_result_row_count": 67200,
+    "dataset_count": 169,
+    "dataset_result_row_count": 63906,
     "excluded_datasets": [
-      "poisson_timestamps"
+      "Arade",
+      "poisson_timestamps",
+      "supply_chain_customer",
+      "supply_chain_location"
     ],
     "family_best_aggregate_row_count": 1383,
+    "measured_dataset_count": 18,
     "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,
+    "paper_leaderboard_row_count": 0,
     "runtime_configuration_count": 931,
     "runtime_count": 3,
     "runtimes": [
@@ -20,10 +25,11 @@
       "python"
     ],
     "scope_count": 5,
-    "source_report_file_count": 114
+    "source_report_file_count": 108
   },
   "data_file": "data.json",
-  "data_sha256": "47ddcf459b1eedd8b1dcf89d07ee544e10b527e6da24c64f81de18628b324454",
+  "data_sha256": "7618054cc2699fd855f673bfd41f7f5b94ee466028043bc669e457ead1984f63",
+  "dataset_catalog_sha256": "a5930a8a0cd52cfbd15c176e8384184fbbdb8778b67ee8e3fe923d5c00cfac82",
   "excluded_content": [
     "raw datasets",
     "user uploads",
@@ -63,36 +69,6 @@
       "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",
@@ -606,29 +582,17 @@
   ],
   "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"
+    },
+    {
+      "path": "dataset-catalog.json",
+      "role": "reviewed_dataset_catalog",
+      "sha256": "a5930a8a0cd52cfbd15c176e8384184fbbdb8778b67ee8e3fe923d5c00cfac82",
+      "status": "reviewed_public_catalog"
     }
   ]
 }

style.css

@@ -10,3 +10,7 @@
 .score-controls{display:flex;align-items:start;gap:20px;padding:12px 14px;margin:6px 0 12px;border:1px solid var(--line);border-radius:var(--radius);background:var(--soft)}.score-controls label{min-width:320px}.score-controls p{font-size:11px;line-height:1.7;margin:0;max-width:90ch}.score-controls select{height:35px}@media(max-width:768px){.score-controls{flex-direction:column;gap:10px}.score-controls label{min-width:0;width:100%}}
 .audit-badge{display:block;color:var(--muted);font-size:10px;margin-top:4px}.audit-notice{font-size:12px;padding:10px 14px;margin:8px 0;border-left:3px solid var(--accent);background:var(--accent-soft);color:var(--text)}
 .documentation-view{max-width:1180px}.documentation-head{display:flex;justify-content:space-between;align-items:end;gap:28px;margin-bottom:10px}.documentation-head>div{min-width:0}.documentation-search{width:min(390px,42%);flex:0 0 auto}.reference-source{margin:8px 0 4px;color:var(--muted);font-size:12px}.documentation-status{margin:14px 0;color:var(--muted);font-size:12px}.documentation-grid{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:14px}.documentation-card{min-width:0;padding:18px;background:var(--surface);border:1px solid var(--line);border-radius:var(--radius)}.documentation-card h3,.documentation-card h4{margin:0;color:var(--text);line-height:1.35}.documentation-card h4{font-size:16px}.documentation-card-head{display:flex;justify-content:space-between;align-items:start;gap:16px}.documentation-code{display:block;margin-top:3px;color:var(--muted);font:11px "SFMono-Regular",Consolas,monospace;overflow-wrap:anywhere}.documentation-count{flex:0 0 auto;padding:3px 7px;border-radius:4px;background:var(--soft);color:var(--muted);font-size:10px}.documentation-description{margin:12px 0;color:var(--text);font-size:13px;line-height:1.65}.documentation-note{margin:10px 0;padding:9px 11px;border-left:2px solid var(--line);color:var(--muted);font-size:12px}.documentation-references{margin-top:12px;font-size:12px}.documentation-references>strong{font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:var(--muted)}.documentation-references ul{list-style:none;padding:0;margin:6px 0 0}.documentation-references li{padding:5px 0;border-top:1px solid var(--line);overflow-wrap:anywhere}.documentation-references small{display:block;margin-top:1px;color:var(--muted);font-size:10px}.reference-empty{margin:12px 0 0;color:var(--muted);font-size:11px}.configuration-details{margin-top:13px;border-top:1px solid var(--line);padding-top:10px}.configuration-details summary{cursor:pointer;color:var(--accent);font-size:12px;font-weight:600}.configuration-details ul{display:flex;flex-wrap:wrap;gap:6px;list-style:none;padding:10px 0 0;margin:0}.configuration-details li{max-width:100%;padding:4px 7px;border-radius:4px;background:var(--soft);font:10px "SFMono-Regular",Consolas,monospace;overflow-wrap:anywhere}.operator-group{margin-top:24px}.operator-group>h3{margin:0 0 10px;padding-bottom:8px;border-bottom:1px solid var(--line)}.operator-card{padding:16px}.documentation-error,.documentation-empty{grid-column:1/-1;margin:0;padding:22px;border:1px solid var(--line);border-radius:var(--radius);color:var(--muted);background:var(--surface)}.documentation-error{border-left:3px solid #b34938;color:var(--text)}@media(max-width:768px){.documentation-head{align-items:stretch;flex-direction:column;gap:14px}.documentation-search{width:100%}.documentation-grid{grid-template-columns:1fr}.documentation-card{padding:15px}.documentation-card-head{gap:10px}}
+.operator-summary{display:grid;grid-template-columns:repeat(6,minmax(0,1fr));gap:1px;margin:16px 0;background:var(--line);border:1px solid var(--line);border-radius:var(--radius);overflow:hidden}.operator-summary>div{padding:12px;background:var(--surface);text-align:center}.operator-summary strong{display:block;font-size:20px;line-height:1.2;font-variant-numeric:tabular-nums}.operator-summary span{display:block;margin-top:4px;color:var(--muted);font-size:10px}.documentation-native-name{display:block;margin-top:2px;color:var(--muted);font-size:11px}.implementation-details{margin-top:14px;padding-top:11px;border-top:1px solid var(--line)}.implementation-details>summary{cursor:pointer;color:var(--accent);font-size:12px;font-weight:650}.implementation-list{display:grid;gap:9px;margin-top:11px}.implementation-entry{padding:12px;border:1px solid var(--line);border-radius:6px;background:var(--soft)}.implementation-head{display:flex;align-items:start;justify-content:space-between;gap:12px}.implementation-head strong{font-size:12px}.implementation-layer{flex:0 0 auto;padding:2px 6px;border:1px solid var(--line);border-radius:999px;color:var(--muted);font-size:9px;text-transform:uppercase;letter-spacing:.05em}.implementation-entry dl{display:grid;gap:6px;margin:10px 0 0}.implementation-entry dl>div{display:grid;grid-template-columns:62px minmax(0,1fr);gap:8px}.implementation-entry dt{color:var(--muted);font-size:10px;font-weight:650;text-transform:uppercase;letter-spacing:.04em}.implementation-entry dd{margin:0;font-size:11px;line-height:1.5;overflow-wrap:anywhere}.implementation-entry .documentation-references{font-size:11px}.implementation-entry .documentation-references>strong{font-size:9px}
+.dataset-catalog-panel{margin:18px 0 20px;padding:18px;border:1px solid var(--line);border-radius:var(--radius);background:var(--surface)}.dataset-catalog-head{display:flex;align-items:end;justify-content:space-between;gap:24px}.dataset-catalog-head>div:first-child{min-width:0}.dataset-catalog-controls{display:grid;grid-template-columns:180px minmax(220px,320px);gap:10px;flex:0 0 auto}.dataset-catalog{max-height:430px;overflow:auto;padding-right:5px}.dataset-category{margin-top:18px}.dataset-category:first-child{margin-top:0}.dataset-category>h3{position:sticky;top:0;z-index:1;display:flex;align-items:center;gap:8px;margin:0;padding:8px 2px;background:var(--surface);border-bottom:1px solid var(--line);font-size:14px}.dataset-category>h3 span{padding:2px 6px;border-radius:999px;background:var(--soft);color:var(--muted);font-size:9px}.dataset-list{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px;padding-top:8px}.dataset-entry{min-width:0;padding:10px;border:1px solid var(--line);border-radius:6px;background:var(--bg)}.dataset-entry.measured{border-left:3px solid var(--accent)}.dataset-entry.selected{box-shadow:inset 0 0 0 1px var(--accent);background:var(--accent-soft)}.dataset-entry button{display:flex;align-items:start;justify-content:space-between;gap:8px;width:100%;padding:0;border:0;background:transparent;color:var(--text);text-align:left}.dataset-entry button:hover strong{color:var(--accent);text-decoration:underline}.dataset-entry strong{display:block;font-size:12px;line-height:1.35;overflow-wrap:anywhere}.dataset-entry small{display:block;margin-top:2px;color:var(--muted);font:9px "SFMono-Regular",Consolas,monospace;overflow-wrap:anywhere}.dataset-state{flex:0 0 auto;max-width:92px;padding:2px 5px;border-radius:4px;background:var(--soft);color:var(--muted);font-size:8px;line-height:1.35;text-align:right}.dataset-entry.measured .dataset-state{background:var(--accent-soft);color:var(--accent)}.dataset-entry p{margin:7px 0 0;color:var(--muted);font-size:9px;line-height:1.45}.dataset-entry .dataset-snapshot-note{color:#9a5a16}.dataset-links{display:flex;flex-wrap:wrap;gap:4px 10px;margin-top:6px}.dataset-links a,.dataset-source{font-size:9px;overflow-wrap:anywhere}
+@media(max-width:1000px){.operator-summary{grid-template-columns:repeat(3,1fr)}.dataset-list{grid-template-columns:repeat(2,minmax(0,1fr))}.dataset-catalog-head{align-items:stretch;flex-direction:column;gap:12px}.dataset-catalog-controls{width:100%;grid-template-columns:1fr 1.5fr}}
+@media(max-width:768px){.operator-summary{grid-template-columns:repeat(2,1fr)}.implementation-entry dl>div{grid-template-columns:1fr;gap:1px}.dataset-catalog-panel{padding:14px}.dataset-catalog-controls,.dataset-list{grid-template-columns:1fr}.dataset-catalog{max-height:520px}}