Publish lossless DBP native-float remeasurement

Complete 169-dataset native float audit: 162 measured datasets and 4096 nonempty float columns. All C++, Java and Python native values verified bit-exact. Encode and decode timing include scale/mode processing; frame bytes include dtype/mode/scale/count metadata. New column downloads and audit page remain separate from historical Overall ranks. Timing is a shared-server single-pass diagnostic with four workers.

.gitattributes

@@ -34,3 +34,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 data.json filter=lfs diff=lfs merge=lfs -text
+dbp-audit-columns.csv filter=lfs diff=lfs merge=lfs -text
+dbp-audit.json filter=lfs diff=lfs merge=lfs -text

README.md

@@ -25,7 +25,7 @@ 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`, `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.
+Publish `dbp-audit.html`, `dbp-audit.js`, `dbp-audit.schema.json`, `dbp-audit.json`, `dbp-audit-columns.csv`, and `dbp-audit-build-receipt.json` alongside `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.
 
@@ -37,6 +37,7 @@ Only measurements in the authoritative current project scope are exported. Missi
 - 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
+- Independent DBP native-float audit with complete frame sizes, encode/decode boundaries, bitwise verification, runtime and dtype filters, per-column JSON/CSV downloads, and source/build receipts
 - Searchable Methods documentation and a 30-family operator catalog with 102 implementation-directory entries, references, I/O contracts, examples, and status
 
 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.
@@ -44,3 +45,11 @@ The dataset catalog and the measured benchmark scope are separate. All 169 catal
 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`.
 
 Source project: https://github.com/xjz17/web_compression
+
+## DBP native-float remeasurement
+
+[DBP full-wire audit](https://thulab-compressionbenchmark.static.hf.space/dbp-audit.html) publishes a separate frozen 169-dataset native-float campaign across C++, Java, and Python. Exact float32 and float64 widths are retained. Encode timing includes scale search, conversion, allocation, and the entire DBF1/DBF2 frame; decode timing includes header parsing, allocation, and inverse scaling or IEEE reconstruction. Frame sizes include the 10-byte dtype/mode/scale/count header per block. Validity sidecars are accounted for separately. Every valid value must match the original native IEEE bits after decoding, and all three implementations must produce the same complete-frame sequence digest per aggregate.
+
+This campaign uses a different typed input and column scope from the historical leaderboard CSVs. It therefore does not replace their DBP rows or participate in their Overall scores and Average Rank. Timings are single-repeat diagnostics on a shared server, with warmup and CPU affinity recorded; they are not controlled publication-level runtime comparisons.
+
+The source checkout includes `scripts/build_dbp_audit_payload.py`. Its complete-publication mode requires the frozen campaign binding, source receipts, normalized three-runtime result records, execution-artifact manifest, and environment receipt. It rejects incomplete scope, missing results, changed inputs or artifacts, unequal frame hashes, incorrect native widths, and unverified values. Its optional partial-output mode is restricted to a directory outside the deployment payload.

app.js

@@ -83,7 +83,7 @@ function refresh() {
   currentRows=aggregate(filteredRecords(true));
   const audit=snapshot.benchmark?.method_audits?.DBP;
   $('audit-notice').hidden=!audit||!currentRows.some(r=>r.family==='DBP');
-  $('audit-notice').textContent=audit?'DBP measurement audit: '+audit.timing+' '+audit.storage+' Float end-to-end losslessness is not established. See method details.':'';
+  $('audit-notice').innerHTML=audit?`<strong>Historical DBP leaderboard snapshot.</strong> ${escape(audit.timing)} ${escape(audit.storage)} The separate DBF1/DBF2 native-float audit uses the latest frozen typed dataset receipts and is excluded from Overall scores and Average Rank. <a href="./dbp-audit.html">Open the full-wire audit →</a>`:'';
   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(),measuredCount=new Set(records.map(r=>r.dataset)).size,ds=s.dataset==='all'?`all ${measuredCount} measured datasets`:datasetDisplayName(s.dataset);
@@ -111,7 +111,7 @@ function showMethod(method,focus=false) {
   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, audit=snapshot.benchmark?.method_audits?.[row.family];
   const source=row.source.slice().sort((a,b)=>a.dataset.localeCompare(b.dataset));
-  detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${fmt(row.compression_time,2)}</strong><span>encoding ns/point</span></div><div><strong>${fmt(row.decompression_time,2)}</strong><span>decoding ns/point</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${audit?`<div class="notice"><strong>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>`:''}${pipeline&&!audit?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}<p class="muted">Dataset metrics below come from the published result files. Independent round-trip evidence and hardware are ${snapshot.benchmark?.roundtrip_evidence?'documented in the manifest':'not reported for this snapshot'}.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Rate ↓</th><th>Encode ns/point ↓</th><th>Decode ns/point ↓</th><th>Original bytes</th><th>Compressed bytes</th><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 class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${fmt(r.compression_time,2)}</td><td class="numeric">${fmt(r.decompression_time,2)}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${fmt(r.dataset_score,4)}</td><td class="numeric">${fmt(r.dataset_rank,2)}</td><td class="numeric">${fmt(r.dataset_candidate_count,0)}</td></tr>`).join('')}</tbody></table></div>`;
+  detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${fmt(row.compression_time,2)}</strong><span>encoding ns/point</span></div><div><strong>${fmt(row.decompression_time,2)}</strong><span>decoding ns/point</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${audit?`<div class="notice"><strong>Historical measurement audit · ${escape(audit.audited_at)}</strong>${[audit.implementation,audit.timing,audit.storage,audit.roundtrip,audit.comparison].map(n=>`<p>${escape(n)}</p>`).join('')}${row.family==='DBP'?'<p>The latest DBF1/DBF2 native-float audit has a separate typed-data scope and does not replace these rows or enter their rankings.</p><a href="./dbp-audit.html">Open the independent full-wire audit →</a>':''}</div>`:''}${pipeline&&!audit?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}<p class="muted">Dataset metrics below come from the published result files. Independent round-trip evidence and hardware are ${snapshot.benchmark?.roundtrip_evidence?'documented in the manifest':'not reported for this snapshot'}.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Rate ↓</th><th>Encode ns/point ↓</th><th>Decode ns/point ↓</th><th>Original bytes</th><th>Compressed bytes</th><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 class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${fmt(r.compression_time,2)}</td><td class="numeric">${fmt(r.decompression_time,2)}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${fmt(r.dataset_score,4)}</td><td class="numeric">${fmt(r.dataset_rank,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});}
 }
@@ -180,7 +180,7 @@ function renderMethodDocumentation() {
   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>';
+  container.innerHTML=rows.length?rows.map(({family,entry,names,note})=>{const display=entry.display_name||family,isDBP=family.toUpperCase()==='DBP';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)}${isDBP?'<a class="quiet-button documentation-action" href="./dbp-audit.html">Open DBF1 / DBF2 full-wire audit →</a>':''}<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 renderOperatorDocumentation() {
   const container=$('operator-catalog'),status=$('operator-doc-status');
@@ -312,5 +312,5 @@ function setupTheme() {
 setupTheme();
 void loadReferenceCatalog();
 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(); }
+try { const response=await fetch('./ui-data.json?v=20261009-dbp-audit-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>';}

data.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:7618054cc2699fd855f673bfd41f7f5b94ee466028043bc669e457ead1984f63
-size 34661683
+oid sha256:7b5bd2bf29b7794a6b08e545cbc2a9244f7a0efcf9bad68e6e8355455327ca37
+size 34662206

dbp-audit-build-receipt.json

@@ -0,0 +1,176 @@
+{
+  "schema": "dbp-native-float-audit-build-v1",
+  "status": "passed",
+  "created_at_utc": "2026-10-09T03:41:20.288512+00:00",
+  "mode": "complete",
+  "summary": {
+    "dataset_receipt_count": 169,
+    "measured_dataset_count": 162,
+    "n_a_dataset_count": 7,
+    "schema_aggregate_count": 4190,
+    "nonempty_aggregate_count": 4096,
+    "n_a_aggregate_count": 94,
+    "datasets_with_float_schema_count": 163,
+    "no_float_schema_dataset_count": 6,
+    "float32_aggregate_count": 2332,
+    "float64_aggregate_count": 1858,
+    "all_null_nonempty_aggregate_count": 92,
+    "zero_row_aggregate_count": 2,
+    "valid_value_count": 1482485088,
+    "native_values_bytes": 9748288680,
+    "float32_native_values_bytes": 2111592024,
+    "float64_native_values_bytes": 7636696656,
+    "validity_bytes": 208277366,
+    "logical_blocks": 5405223,
+    "header_bytes": 54052230
+  },
+  "gates": {
+    "scope": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "compact_collection": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "input_scope_receipt": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "source_manifest_coverage": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "source_manifest": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "source_preflight": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "source_authority": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "source_aggregate_uniqueness": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "source_aggregate_shape": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "source_counts": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "column_inventory": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "dtype_width": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "native_bytes": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "header_bytes": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "dataset_runtime_receipts": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "runtime_coverage": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "runtime_totals": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "source_result_exactness": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "bitwise_verification": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "mode_counts": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "n_a_semantics": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "frame_sequence_sha256": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "cross_runtime": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "campaign_run_receipt": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "artifact_manifest": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "campaign_binding": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "frame_verification": {
+      "status": "passed",
+      "failure_count": 0
+    },
+    "environment": {
+      "status": "passed",
+      "failure_count": 0
+    }
+  },
+  "errors": [],
+  "suppressed_error_count": 0,
+  "inputs": {
+    "scope_sha256": "0fabc01f25d62ddb49585b3208103543b16c6e50340195360a0516411fa148b4",
+    "source_column_inventory_sha256": "f94ed9a9dfd95a74f5c48986d650f30a8f867a21e1a18ef02be6610206a21453",
+    "artifact_manifest_sha256": "65c71e76b36196328ae7ecc6b2c456e941226ef9b7e300dd623ce32a6a3d2cf2",
+    "campaign_binding_sha256": "8bbc012129798d7d8af52c39872d6453863df56684c20b507ae3d226bdbd084c",
+    "frame_verification_receipt_sha256": "8bcf811178f8b76e3e379ee659b01061420b0c55e7808a81b9c7e245240fb7d2",
+    "compact_collection_receipt_sha256": "969a6b417d0ff541eb1583f51861ca79bc6f8e70a0c9e818efbe95e3f3fb4c93",
+    "input_scope_receipt_sha256": "e1a7955aa457dfbda38f182806bde4dcc8c87d58d90c031dd5e65e346c669c00",
+    "campaign_run_receipt_sha256": "22a89a5f6abddcdbdfabe8b7826ac6fa80a681812559cc1f0707e66beee0a227",
+    "campaign_progress_sha256": "a926e03715d60c9858b5899fac25756e25451f1e53c851ec1d5067db9c353af1",
+    "environment_sha256": "472c685502e53d740e45730ab4ceaaebf87cbb539ba0666e479b43b97c807c2c",
+    "source_evidence_chain_sha256": "9a9972cb684000d6c9788865c2e949a3a69cae11a17342caef00a718f1583ab7",
+    "runtime_result_chain_sha256": {
+      "cpp": "1425ca9522347fe60ad2c83481779a1a595fcd7635e2dccc04a95483357a4f9a",
+      "java": "a7a55d5e216cfa82cf8513d665a8e551c41f2b7ce1e1d7415295bd856fa390c1",
+      "python": "1c8813058d1d946d910cadb62141b75adff197d74dbd923135a7ad8a1c6db995"
+    },
+    "dataset_run_receipt_chain_sha256": "e35abb086077d8797981d0812ec117f207f55a1ad5a4c0d83e3453b7a55a7478",
+    "source_file_count": 338,
+    "recorded_block_manifest_count": 169,
+    "runtime_result_file_count": 507,
+    "compact_collection_file_count": 1022
+  },
+  "outputs": {
+    "dbp-audit.json": {
+      "bytes": 24243804,
+      "sha256": "febe0d4494cf3778bb3e386ac8674f24406e29d1d7d9b47bd834b332b0e201fb"
+    },
+    "dbp-audit-columns.csv": {
+      "bytes": 11753491,
+      "sha256": "ed617bab971dfaa2e398aca2ad9fb73ee5b0d5b8c614667d3c95fa3e02247d7f"
+    }
+  }
+}

dbp-audit-columns.csv

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

dbp-audit.html

@@ -0,0 +1,87 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <meta name="description" content="Independent DBP DBF1 and DBF2 full-wire native floating-point audit for the THULab compression benchmark.">
+  <meta name="color-scheme" content="light dark">
+  <title>THULab | DBP Full-wire Audit</title>
+  <link rel="stylesheet" href="style.css?v=20261009-dbp-audit-v1">
+  <script src="dbp-audit.js?v=20261009-dbp-audit-v1" type="module"></script>
+</head>
+<body>
+  <a class="skip-link" href="#audit-content">Skip to audit results</a>
+  <header class="site-header">
+    <a class="brand" href="./index.html#methods"><span class="brand-mark">THU</span><span>THULab <span class="brand-sub">Compression Benchmark</span></span></a>
+    <div class="header-links"><a href="./index.html#methods">Methods</a><a href="https://github.com/xjz17/web_compression" target="_blank" rel="noopener">Project code ↗</a><button id="theme" class="quiet-button" type="button" aria-label="Switch color theme">Theme</button></div>
+  </header>
+  <main id="audit-content" class="dbp-audit-main">
+    <section class="audit-hero" aria-labelledby="audit-title">
+      <div>
+        <p class="eyebrow">Independent native-float diagnostic</p>
+        <h1 id="audit-title">DBP full-wire audit</h1>
+        <p class="intro-text">Bit-exact DBF1 binary64 and DBF2 binary32 measurements across C++, Java, and Python.</p>
+      </div>
+      <div class="audit-state-card"><span>Page status</span><strong id="audit-state" class="status-chip status-unknown">Loading</strong><small id="audit-generated">Reading dbp-audit.json…</small></div>
+    </section>
+
+    <div id="load-error" class="error-message" role="alert" hidden></div>
+    <section class="notice audit-scope-notice" aria-label="Scope boundary">
+      <strong>Separate evidence scope</strong>
+      <p>This audit uses the latest frozen typed dataset receipts. It does not replace the historical DBP kernel rows in the main leaderboard and does not participate in Overall scores or Average Rank.</p>
+      <p>Frame bytes include the 10-byte DBF header and integer body. Validity sidecars are reported separately, so frame bytes are not a full-storage total. Encoding includes scale selection and serialization; decoding includes header parsing and inverse scaling or IEEE-bit reconstruction.</p>
+    </section>
+
+    <section aria-labelledby="coverage-title">
+      <div class="section-heading"><div><h2 id="coverage-title">Receipt coverage</h2><p class="muted">Counts are read or derived from the loaded audit JSON. Declared/detail mismatches are shown below.</p></div><a href="dbp-audit.json" download>Download full result JSON</a></div>
+      <div id="audit-summary" class="audit-summary" aria-live="polite"></div>
+      <p id="scope-validation" class="documentation-status"></p>
+    </section>
+
+    <section class="audit-meta-grid" aria-label="Measurement context">
+      <article><h2>Measurement boundary</h2><dl id="measurement-meta" class="audit-definitions"></dl></article>
+      <article><h2>Server and load</h2><dl id="environment-meta" class="audit-definitions"></dl></article>
+    </section>
+
+    <section aria-labelledby="runtime-title">
+      <div class="section-heading"><div><h2 id="runtime-title">Runtime status</h2><p class="muted">Every published runtime status comes directly from the audit receipt.</p></div></div>
+      <div id="runtime-status" class="runtime-status-grid"></div>
+    </section>
+
+    <section class="audit-results" aria-labelledby="column-title">
+      <div class="section-heading">
+        <div><h2 id="column-title">Column results</h2><p class="muted">Native-width denominators use 4 bytes per float32 value and 8 bytes per float64 value. No cross-runtime ranking is computed.</p></div>
+        <div class="toolbar-actions"><button id="download-column-json" class="quiet-button" type="button" disabled>Filtered JSON</button><button id="download-column-csv" class="primary-button" type="button" disabled>Filtered CSV</button></div>
+      </div>
+      <div class="audit-filters">
+        <label>Runtime<select id="audit-runtime"><option value="all">All runtimes</option></select></label>
+        <label>Native dtype<select id="audit-dtype"><option value="all">float32 and float64</option><option value="float32">float32</option><option value="float64">float64</option></select></label>
+        <label>Measurement status<select id="audit-status"><option value="all">All statuses</option></select></label>
+        <label>Dataset or column<input id="audit-search" type="search" placeholder="Dataset, column, or aggregate ID" autocomplete="off"></label>
+      </div>
+      <div class="table-footer"><span id="column-result-count" aria-live="polite">Waiting for results…</span><span><a href="dbp-audit-columns.csv" download>Full column CSV</a> · DBF frame bytes exclude validity sidecars.</span></div>
+      <div class="table-wrap audit-table-wrap" tabindex="0" aria-label="Scrollable DBP audit results">
+        <table id="audit-table">
+          <thead><tr><th>Status</th><th>Runtime</th><th>Dataset</th><th>Column</th><th>Dtype</th><th>Native bytes</th><th>DBF frame bytes</th><th>Rate ↓</th><th>Encode ns/value ↓</th><th>Decode ns/value ↓</th><th>Modes</th><th>Bitwise verified</th></tr></thead>
+          <tbody><tr><td colspan="12" class="loading-cell">Loading DBP audit results…</td></tr></tbody>
+        </table>
+      </div>
+      <div class="audit-pagination"><button id="audit-prev" class="quiet-button" type="button" disabled>Previous</button><span id="audit-page">Page 1</span><button id="audit-next" class="quiet-button" type="button" disabled>Next</button></div>
+    </section>
+
+    <section aria-labelledby="dataset-receipt-title">
+      <div class="section-heading"><div><h2 id="dataset-receipt-title">Dataset receipt status</h2><p class="muted">Dataset status is tracked separately for each runtime, including datasets with no native-float schema.</p></div><span id="dataset-receipt-count" class="muted"></span></div>
+      <div id="dataset-receipts" class="dataset-receipt-grid"></div>
+    </section>
+
+    <section class="audit-reading-note" aria-labelledby="reading-title">
+      <h2 id="reading-title">How to read these diagnostics</h2>
+      <p>These are single-repeat diagnostics on a shared server. CPU affinity, concurrent load, clock, warmup, and runtime build details are shown when the receipt supplies them. Timing differences across runtimes can include runtime and system effects.</p>
+      <p>A scaled block is used only when decimal scaling and inverse reconstruction reproduce every native IEEE lane exactly. Otherwise the whole block stores its original IEEE words. Every measured block must pass a bitwise round trip.</p>
+      <p><a href="dbp-audit.schema.json">Audit JSON schema</a> · <a href="./index.html#methods">Return to Methods</a></p>
+    </section>
+    <noscript><p class="error-message">Enable JavaScript to inspect the audit. You can download <a href="dbp-audit.json">dbp-audit.json</a> directly.</p></noscript>
+    <footer><span>THULab · DBP native-float audit</span><span>Independent from the historical leaderboard</span></footer>
+  </main>
+</body>
+</html>

dbp-audit.js

@@ -0,0 +1,218 @@
+const $ = (id) => document.getElementById(id);
+const escapeHtml = (value) => String(value ?? '').replace(/[&<>"']/g, (character) => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[character]));
+const finiteNumber = (value) => value !== null && value !== '' && Number.isFinite(Number(value)) ? Number(value) : null;
+const integer = (value) => finiteNumber(value) === null ? null : Math.trunc(Number(value));
+const countFormat = (value) => finiteNumber(value) === null ? 'Not reported' : Number(value).toLocaleString('en-US',{maximumFractionDigits:0});
+const metricFormat = (value,digits=3) => finiteNumber(value) === null ? 'N/A' : Number(value).toLocaleString('en-US',{minimumFractionDigits:digits,maximumFractionDigits:digits});
+const runtimeLabel = (runtime) => ({cpp:'C++',java:'Java',python:'Python'}[runtime] || String(runtime || 'Unknown'));
+const successfulStatus = (value) => ['ok','complete','passed'].includes(normalizeStatus(value));
+const PAGE_SIZE = 100;
+const EXPECTED_RUNTIMES = ['cpp','java','python'];
+const EXPECTED_COMPLETE_SUMMARY = {dataset_receipt_count:169,measured_dataset_count:162,n_a_dataset_count:7,schema_aggregate_count:4190,nonempty_aggregate_count:4096,n_a_aggregate_count:94};
+const REQUIRED_EVIDENCE_SHA_FIELDS = ['scope_sha256','source_column_inventory_sha256','runtime_artifact_manifest_sha256','campaign_binding_sha256','frame_verification_receipt_sha256','compact_collection_receipt_sha256','input_scope_receipt_sha256','campaign_run_receipt_sha256','campaign_progress_sha256','environment_receipt_sha256','source_evidence_chain_sha256'];
+const REQUIRED_COLUMN_SHA_FIELDS = ['frame_sequence_sha256','expected_sequence_chain_sha256','result_sha256','receipt_sha256','source_manifest_receipt_sha256','source_aggregates_sha256','source_blocks_sha256','source_block_catalog_sha256','runtime_artifact_manifest_sha256','source_column_inventory_sha256','scope_sha256'];
+const SHA256_PATTERN = /^[0-9a-f]{64}$/;
+
+let audit=null;
+let columns=[];
+let datasetReceipts=[];
+let filteredColumns=[];
+let page=1;
+
+function normalizeStatus(value) {
+  const text=String(value??'').trim().toLowerCase().replace(/[\s/-]+/g,'_');
+  return text||'unknown';
+}
+function statusLabel(value) {
+  const status=normalizeStatus(value);
+  if(status==='n_a'||status==='na')return 'N/A';
+  return status.replaceAll('_',' ').replace(/\b\w/g,letter=>letter.toUpperCase());
+}
+function statusChip(value) {
+  const status=normalizeStatus(value),css=status.replaceAll('_','-');
+  return `<span class="status-chip status-${escapeHtml(css)}">${escapeHtml(statusLabel(status))}</span>`;
+}
+function normalizeDtype(value,width) {
+  const text=String(value??'').toLowerCase();
+  if(text.includes('32')||Number(width)===4)return 'float32';
+  if(text.includes('64')||Number(width)===8)return 'float64';
+  return text||'unknown';
+}
+function normalizeColumn(row) {
+  const valid=integer(row.valid_count??row.verified_values),nativeBytes=integer(row.native_bytes??row.original_bytes),frameBytes=integer(row.frame_bytes??row.compressed_bytes??row.codec_wire_bytes);
+  const encodeTotal=finiteNumber(row.encode_ns),decodeTotal=finiteNumber(row.decode_ns);
+  return {...row,
+    status:normalizeStatus(row.status),runtime:String(row.runtime??row.implementation_language??''),dataset:String(row.dataset??row.dataset_id??''),column:String(row.column??row.source_column??row.aggregate_id??''),aggregate_id:String(row.aggregate_id??''),dtype:normalizeDtype(row.dtype,row.width),
+    rows:integer(row.rows??row.row_count),valid_count:valid,missing_count:integer(row.missing_count),native_bytes:nativeBytes,frame_bytes:frameBytes,
+    compression_rate:finiteNumber(row.compression_rate??(nativeBytes>0&&frameBytes!==null?frameBytes/nativeBytes:null)),
+    encode_ns_per_value:finiteNumber(row.encode_ns_per_value??row.compression_time_ns_per_point??(valid>0&&encodeTotal!==null?encodeTotal/valid:null)),
+    decode_ns_per_value:finiteNumber(row.decode_ns_per_value??row.decompression_time_ns_per_point??(valid>0&&decodeTotal!==null?decodeTotal/valid:null)),
+    blocks:integer(row.blocks),scaled_blocks:integer(row.scaled_blocks),raw_blocks:integer(row.raw_blocks),validity_bytes:integer(row.validity_bytes),header_bytes:integer(row.header_bytes),verified_values:integer(row.verified_values),
+    frame_sequence_sha256:String(row.frame_sequence_sha256??''),receipt_sha256:String(row.receipt_sha256??''),message:String(row.message??'')};
+}
+function normalizeDatasetReceipt(row) {
+  return {...row,dataset:String(row.dataset??row.dataset_id??''),runtime:String(row.runtime??''),status:normalizeStatus(row.status),reason:String(row.reason??row.message??''),receipt_sha256:String(row.receipt_sha256??'')};
+}
+function uniqueAggregateKey(row) {
+  return row.aggregate_id||`${row.dataset}\0${row.column}\0${row.dtype}`;
+}
+function groupBy(items,keyFn) {
+  const groups=new Map();
+  for(const item of items){const key=keyFn(item);if(!groups.has(key))groups.set(key,[]);groups.get(key).push(item);}
+  return groups;
+}
+function summaryObservation(columnRows=columns,receiptRows=datasetReceipts) {
+  const datasetGroups=groupBy(receiptRows.filter(row=>row.dataset),row=>row.dataset);
+  const aggregateGroups=groupBy(columnRows.filter(row=>uniqueAggregateKey(row)),uniqueAggregateKey);
+  return {
+    dataset_receipt_count:datasetGroups.size,
+    measured_dataset_count:[...datasetGroups.values()].filter(rows=>rows.some(row=>successfulStatus(row.status))).length,
+    n_a_dataset_count:[...datasetGroups.values()].filter(rows=>rows.length&&rows.every(row=>row.status==='n_a')).length,
+    schema_aggregate_count:aggregateGroups.size,
+    nonempty_aggregate_count:[...aggregateGroups.values()].filter(rows=>rows.some(row=>(row.valid_count??0)>0&&successfulStatus(row.status))).length,
+    n_a_aggregate_count:[...aggregateGroups.values()].filter(rows=>rows.length&&rows.every(row=>row.status==='n_a')).length,
+  };
+}
+function renderSummary() {
+  const declared=audit.summary||{},observed=summaryObservation();
+  const definitions=[['Dataset receipts','dataset_receipt_count'],['Measured datasets','measured_dataset_count'],['Dataset N/A','n_a_dataset_count'],['Schema aggregates','schema_aggregate_count'],['Nonempty aggregates','nonempty_aggregate_count'],['Aggregate N/A','n_a_aggregate_count']];
+  $('audit-summary').innerHTML=definitions.map(([label,key])=>{const detail=integer(observed[key]),reported=integer(declared[key]),value=detail??reported,suffix=detail!==null&&reported!==null&&detail!==reported?` · JSON summary ${countFormat(reported)}`:'';return `<div><strong>${countFormat(value)}</strong><span>${escapeHtml(label+suffix)}</span></div>`;}).join('');
+}
+function auditValidationErrors(auditData,columnRows,receiptRows) {
+  const errors=[],add=(message)=>{if(errors.length<500)errors.push(message);},declared=auditData.summary||{},observed=summaryObservation(columnRows,receiptRows),complete=normalizeStatus(auditData.status)==='complete';
+  if(auditData.schema_version!=='dbp-native-float-audit-v1')add('schema_version is not dbp-native-float-audit-v1');
+  for(const key of Object.keys(EXPECTED_COMPLETE_SUMMARY)){const expected=integer(declared[key]),actual=integer(observed[key]);if(expected!==null&&actual!==null&&expected!==actual)add(`${key}: summary ${expected}, detail ${actual}`);}
+  if(!complete)return errors;
+  for(const [key,value] of Object.entries(EXPECTED_COMPLETE_SUMMARY)){if(integer(declared[key])!==value)add(`${key}: complete scope requires ${value}`);}
+  const runtimeRows=Array.isArray(auditData.runtimes)?auditData.runtimes:[],runtimeIds=runtimeRows.map(row=>String(row.runtime??''));
+  if(runtimeRows.length!==3||new Set(runtimeIds).size!==3||!EXPECTED_RUNTIMES.every(runtime=>runtimeIds.includes(runtime)))add('complete audit requires exactly C++, Java, and Python runtime receipts');
+  for(const row of runtimeRows){if(normalizeStatus(row.status)!=='complete')add(`${runtimeLabel(row.runtime)} runtime status is not complete`);if(!SHA256_PATTERN.test(String(row.result_sha256??'')))add(`${runtimeLabel(row.runtime)} runtime result chain SHA is absent`);}
+  const byDataset=groupBy(receiptRows.filter(row=>row.dataset),row=>row.dataset);
+  if(receiptRows.length!==507||byDataset.size!==169)add('complete audit requires 507 runtime receipts for 169 unique datasets');
+  for(const [dataset,rows] of byDataset){const ids=rows.map(row=>row.runtime);if(rows.length!==3||new Set(ids).size!==3||!EXPECTED_RUNTIMES.every(runtime=>ids.includes(runtime)))add(`${dataset}: dataset receipts are not exactly C++, Java, and Python`);if(rows.some(row=>!['ok','n_a'].includes(row.status)))add(`${dataset}: dataset receipt has a nonfinal status`);if(new Set(rows.map(row=>row.status)).size!==1)add(`${dataset}: runtime dataset statuses differ`);if(rows.some(row=>!SHA256_PATTERN.test(row.receipt_sha256)))add(`${dataset}: dataset run receipt SHA is absent`);}
+  const aggregateGroups=groupBy(columnRows.filter(row=>row.aggregate_id),row=>row.aggregate_id);
+  if(columnRows.length!==12570||aggregateGroups.size!==4190)add('complete audit requires 12,570 runtime rows for 4,190 unique aggregates');
+  const exactFields=['status','dataset','column','dtype','width','max_point','rows','valid_count','missing_count','native_bytes','frame_bytes','validity_bytes','header_bytes','blocks','scaled_blocks','raw_blocks','verified_values','frame_sequence_sha256','expected_sequence_chain_sha256','receipt_sha256','source_manifest_receipt_sha256','source_aggregates_sha256','source_blocks_sha256','source_block_catalog_sha256','runtime_artifact_manifest_sha256','source_column_inventory_sha256','scope_sha256'];
+  for(const row of columnRows){
+    const id=row.aggregate_id||'(missing aggregate_id)',width=row.dtype==='float32'?4:row.dtype==='float64'?8:null,expectedStatus=(row.valid_count??0)>0?'ok':'n_a';
+    if(!row.aggregate_id)add('a complete column row is missing aggregate_id');
+    if(!byDataset.has(row.dataset))add(`${id}: column dataset is absent from dataset receipts`);
+    for(const field of ['width','max_point','rows','valid_count','missing_count','native_bytes','frame_bytes','validity_bytes','header_bytes','encode_ns','decode_ns','blocks','scaled_blocks','raw_blocks','verified_values'])if(finiteNumber(row[field])===null)add(`${id} ${runtimeLabel(row.runtime)}: ${field} is absent or invalid`);
+    if(row.status!==expectedStatus)add(`${id} ${runtimeLabel(row.runtime)}: status does not match valid_count`);
+    if(!width||row.native_bytes!==width*row.valid_count)add(`${id} ${runtimeLabel(row.runtime)}: native-byte accounting differs`);
+    if(row.rows!==row.valid_count+row.missing_count)add(`${id} ${runtimeLabel(row.runtime)}: row accounting differs`);
+    if(row.header_bytes!==10*row.blocks)add(`${id} ${runtimeLabel(row.runtime)}: header-byte accounting differs`);
+    if(row.verified_values!==row.valid_count)add(`${id} ${runtimeLabel(row.runtime)}: verified value count differs`);
+    if(row.scaled_blocks+row.raw_blocks!==row.blocks)add(`${id} ${runtimeLabel(row.runtime)}: mode counts differ`);
+    if(row.valid_count>0&&(finiteNumber(row.compression_rate)===null||finiteNumber(row.encode_ns_per_value)===null||finiteNumber(row.decode_ns_per_value)===null))add(`${id} ${runtimeLabel(row.runtime)}: measured rate or timing is absent`);
+    for(const field of REQUIRED_COLUMN_SHA_FIELDS)if(!SHA256_PATTERN.test(String(row[field]??'')))add(`${id} ${runtimeLabel(row.runtime)}: ${field} is absent or invalid`);
+  }
+  for(const [aggregateId,rows] of aggregateGroups){const ids=rows.map(row=>row.runtime);if(rows.length!==3||new Set(ids).size!==3||!EXPECTED_RUNTIMES.every(runtime=>ids.includes(runtime)))add(`${aggregateId}: result rows are not exactly C++, Java, and Python`);for(const field of exactFields)if(new Set(rows.map(row=>JSON.stringify(row[field]??null))).size!==1)add(`${aggregateId}: ${field} differs across runtimes`);}
+  const evidence=auditData.evidence||{};
+  for(const field of REQUIRED_EVIDENCE_SHA_FIELDS)if(!SHA256_PATTERN.test(String(evidence[field]??'')))add(`evidence.${field} is absent or invalid`);
+  const runtimeChains=evidence.runtime_result_chain_sha256||{};for(const runtime of EXPECTED_RUNTIMES)if(!SHA256_PATTERN.test(String(runtimeChains[runtime]??'')))add(`evidence.runtime_result_chain_sha256.${runtime} is absent or invalid`);
+  if(integer(auditData.measurement?.repeats)!==1||integer(auditData.measurement?.warmup_blocks)!==20||integer(auditData.measurement?.header_bytes_per_block)!==10)add('complete audit measurement contract differs');
+  if(auditData.environment?.shared_server!==true||integer(auditData.environment?.cpu?.passed_receipts_at_capture)!==169)add('complete audit environment receipt does not cover all 169 dataset receipts');
+  return errors;
+}
+function validateScope() {
+  const errors=auditValidationErrors(audit,columns,datasetReceipts);
+  const complete=normalizeStatus(audit.status)==='complete';
+  $('scope-validation').className=`documentation-status ${errors.length&&complete?'audit-validation-error':'audit-validation-ok'}`;
+  $('scope-validation').textContent=errors.length?(complete?`Completed receipt has ${errors.length} consistency issue${errors.length===1?'':'s'}. ${errors.slice(0,3).join(' · ')}${errors.length>3?' · …':''}`:`Audit status is ${statusLabel(audit.status)}; ${errors.length} completeness check${errors.length===1?'':'s'} remain unresolved.`):'Loaded summary, runtime, dataset, aggregate, and cross-runtime frame-hash receipts are internally consistent.';
+  const rawPageStatus=normalizeStatus(audit.status),state=$('audit-state');state.textContent=errors.length&&complete?'Failed · inconsistent':successfulStatus(rawPageStatus)&&!complete?'Incomplete · invalid status':statusLabel(rawPageStatus);state.className=`status-chip status-${errors.length&&complete||rawPageStatus==='failed'?'failed':complete?'complete':'incomplete'}`;
+}
+function metadataValue(value) {
+  if(value===null||value===undefined||value==='')return 'Not reported';
+  if(Array.isArray(value))return value.join(', ');
+  if(typeof value==='object')return JSON.stringify(value);
+  return String(value);
+}
+function renderDefinitionList(target,entries) {
+  target.innerHTML=entries.map(([label,value])=>`<dt>${escapeHtml(label)}</dt><dd>${escapeHtml(metadataValue(value))}</dd>`).join('');
+}
+function renderMetadata() {
+  const measurement=audit.measurement||{},environment=audit.environment||{};
+  renderDefinitionList($('measurement-meta'),[
+    ['Context',measurement.context],['Repetitions',measurement.repetitions??measurement.repeats],['Warmup blocks',measurement.warmup_blocks],['Header bytes per block',measurement.header_bytes_per_block],['Clock',measurement.clock??environment.clock],['Encode timing',measurement.encode_boundary],['Decode timing',measurement.decode_boundary],['Ranking integration',measurement.ranking_integration],['Notes',measurement.notes]
+  ]);
+  renderDefinitionList($('environment-meta'),[
+    ['Hardware',environment.hardware],['CPU',environment.cpu],['CPU affinity',environment.cpu_affinity],['Operating system',environment.os],['Concurrent load',environment.concurrent_load??environment.load],['Shared server',environment.shared_server===true?'Yes':environment.shared_server===false?'No':null],['Captured at',environment.captured_at]
+  ]);
+}
+function renderRuntimeStatus() {
+  const runtimes=Array.isArray(audit.runtimes)?audit.runtimes:[];
+  $('runtime-status').innerHTML=runtimes.length?runtimes.map(row=>`<article class="runtime-status-card"><header><h3>${escapeHtml(runtimeLabel(row.runtime))}</h3>${statusChip(row.status)}</header>${row.version?`<p>${escapeHtml(row.version)}</p>`:''}${row.message?`<p>${escapeHtml(row.message)}</p>`:''}${row.result_sha256?`<p class="source-code">Result ${escapeHtml(String(row.result_sha256).slice(0,16))}…</p>`:''}</article>`).join(''):'<p class="documentation-empty">No runtime status receipts are available.</p>';
+}
+function populateFilters() {
+  const runtimeIds=[...new Set([...(audit.runtimes||[]).map(row=>row.runtime),...columns.map(row=>row.runtime)].filter(Boolean))];
+  $('audit-runtime').innerHTML='<option value="all">All runtimes</option>'+runtimeIds.map(runtime=>`<option value="${escapeHtml(runtime)}">${escapeHtml(runtimeLabel(runtime))}</option>`).join('');
+  const statuses=[...new Set(columns.map(row=>row.status).filter(status=>['ok','n_a'].includes(status)))].sort();
+  $('audit-status').innerHTML='<option value="all">All statuses</option>'+statuses.map(status=>`<option value="${escapeHtml(status)}">${escapeHtml(statusLabel(status))}</option>`).join('');
+}
+function filterState() {
+  return {runtime:$('audit-runtime').value,dtype:$('audit-dtype').value,status:$('audit-status').value,search:$('audit-search').value.trim().toLowerCase()};
+}
+function applyFilters(resetPage=true) {
+  const filters=filterState();
+  filteredColumns=columns.filter(row=>(filters.runtime==='all'||row.runtime===filters.runtime)&&(filters.dtype==='all'||row.dtype===filters.dtype)&&(filters.status==='all'||row.status===filters.status)&&(!filters.search||`${row.dataset} ${row.column} ${row.aggregate_id}`.toLowerCase().includes(filters.search)));
+  if(resetPage)page=1;
+  renderColumnTable();renderDatasetReceipts();
+}
+function renderColumnTable() {
+  const totalPages=Math.max(1,Math.ceil(filteredColumns.length/PAGE_SIZE));if(page>totalPages)page=totalPages;
+  const start=(page-1)*PAGE_SIZE,visible=filteredColumns.slice(start,start+PAGE_SIZE),tbody=$('audit-table').querySelector('tbody');
+  tbody.innerHTML=visible.length?visible.map(row=>`<tr><td>${statusChip(row.status)}</td><td>${escapeHtml(runtimeLabel(row.runtime))}</td><td>${escapeHtml(row.dataset||'Unknown')}</td><td>${escapeHtml(row.column||row.aggregate_id||'Unknown')}</td><td class="numeric">${escapeHtml(row.dtype)}</td><td class="numeric">${countFormat(row.native_bytes)}</td><td class="numeric">${countFormat(row.frame_bytes)}</td><td class="numeric">${metricFormat(row.compression_rate,4)}</td><td class="numeric">${metricFormat(row.encode_ns_per_value,2)}</td><td class="numeric">${metricFormat(row.decode_ns_per_value,2)}</td><td class="numeric">${countFormat(row.scaled_blocks)} scaled<span class="mode-count">${countFormat(row.raw_blocks)} raw · ${countFormat(row.blocks)} total</span></td><td class="numeric">${countFormat(row.verified_values)}</td></tr>`).join(''):'<tr><td colspan="12" class="empty-cell">No column result matches these filters.</td></tr>';
+  $('column-result-count').textContent=`${countFormat(filteredColumns.length)} of ${countFormat(columns.length)} runtime / column rows shown${filteredColumns.length?` · rows ${countFormat(start+1)}–${countFormat(Math.min(start+PAGE_SIZE,filteredColumns.length))}`:''}`;
+  $('audit-page').textContent=`Page ${page} of ${totalPages}`;$('audit-prev').disabled=page<=1;$('audit-next').disabled=page>=totalPages;$('download-column-json').disabled=!filteredColumns.length;$('download-column-csv').disabled=!filteredColumns.length;
+}
+function renderDatasetReceipts() {
+  const filters=filterState();
+  const visible=datasetReceipts.filter(row=>(filters.runtime==='all'||row.runtime===filters.runtime)&&(filters.status==='all'||row.status===filters.status)&&(!filters.search||`${row.dataset} ${row.label??''} ${row.reason}`.toLowerCase().includes(filters.search)));
+  $('dataset-receipt-count').textContent=`${countFormat(visible.length)} of ${countFormat(datasetReceipts.length)} runtime receipts · ${countFormat(new Set(visible.map(row=>row.dataset)).size)} datasets`;
+  $('dataset-receipts').innerHTML=visible.length?visible.map(row=>`<article class="dataset-receipt-card"><header><div><strong>${escapeHtml(row.label||row.dataset)}</strong><small>${escapeHtml(runtimeLabel(row.runtime))}${row.label&&row.label!==row.dataset?` · ${escapeHtml(row.dataset)}`:''}</small></div>${statusChip(row.status)}</header>${row.reason?`<p>${escapeHtml(row.reason)}</p>`:''}<p>${integer(row.schema_aggregate_count)!==null?`${countFormat(row.schema_aggregate_count)} schema · `:''}${integer(row.nonempty_aggregate_count)!==null?`${countFormat(row.nonempty_aggregate_count)} nonempty · `:''}${integer(row.n_a_aggregate_count)!==null?`${countFormat(row.n_a_aggregate_count)} N/A`:''}</p>${row.receipt_sha256?`<p class="source-code">Receipt ${escapeHtml(row.receipt_sha256.slice(0,16))}…</p>`:''}</article>`).join(''):'<p class="documentation-empty">No dataset receipt matches these filters.</p>';
+}
+function csvCell(value) {
+  let text=String(value??'');if(/^[=+@-]/.test(text))text=`'${text}`;return `"${text.replaceAll('"','""')}"`;
+}
+function downloadBlob(filename,type,text) {
+  const url=URL.createObjectURL(new Blob([text],{type})),anchor=document.createElement('a');anchor.href=url;anchor.download=filename;anchor.click();setTimeout(()=>URL.revokeObjectURL(url),1000);
+}
+const DOWNLOAD_FIELDS=[
+  'status','runtime','dataset','column','source_column','aggregate_id','dtype','width','max_point','rows','valid_count','missing_count',
+  'native_bytes','frame_bytes','validity_bytes','header_bytes','compression_rate','encode_ns','decode_ns','encode_ns_per_value','decode_ns_per_value',
+  'blocks','scaled_blocks','raw_blocks','verified_values','frame_sequence_sha256','expected_sequence_chain_sha256','result_sha256','receipt_sha256',
+  'source_manifest_receipt_sha256','source_aggregates_sha256','source_blocks_sha256','source_block_catalog_sha256','runtime_artifact_manifest_sha256',
+  'source_column_inventory_sha256','scope_sha256','message'
+];
+function downloadCsv() {
+  const rows=filteredColumns.map(row=>DOWNLOAD_FIELDS.map(field=>csvCell(row[field])).join(','));downloadBlob('THULab-DBP-audit-columns-filtered.csv','text/csv;charset=utf-8','\ufeff'+[DOWNLOAD_FIELDS.join(','),...rows].join('\r\n'));
+}
+function downloadJson() {
+  downloadBlob('THULab-DBP-audit-columns-filtered.json','application/json;charset=utf-8',JSON.stringify({schema_version:audit.schema_version,status:audit.status,filters:filterState(),columns:filteredColumns.map(row=>Object.fromEntries(DOWNLOAD_FIELDS.map(field=>[field,row[field]??null])))},null,2)+'\n');
+}
+function setupEvents() {
+  for(const id of ['audit-runtime','audit-dtype','audit-status'])$(id).addEventListener('change',()=>applyFilters(true));$('audit-search').addEventListener('input',()=>applyFilters(true));
+  $('audit-prev').addEventListener('click',()=>{if(page>1){page--;renderColumnTable();}});$('audit-next').addEventListener('click',()=>{if(page*PAGE_SIZE<filteredColumns.length){page++;renderColumnTable();}});
+  $('download-column-csv').addEventListener('click',downloadCsv);$('download-column-json').addEventListener('click',downloadJson);
+}
+function setupTheme() {
+  let stored;try{stored=localStorage.getItem('thulab-theme');}catch{}
+  const query=new URLSearchParams(location.search).get('__theme'),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{}});
+}
+function initialize() {
+  columns=(Array.isArray(audit.columns)?audit.columns:Array.isArray(audit.results)?audit.results:[]).map(normalizeColumn);datasetReceipts=(Array.isArray(audit.datasets)?audit.datasets:[]).map(normalizeDatasetReceipt);
+  $('audit-generated').textContent=audit.generated_at?`Generated ${String(audit.generated_at).replace('T',' ').replace('Z',' UTC')}`:'Generation time not reported';
+  renderSummary();renderMetadata();renderRuntimeStatus();populateFilters();setupEvents();applyFilters(true);validateScope();document.documentElement.dataset.ready='true';
+}
+
+async function loadAudit() {
+  try {
+    const response=await fetch('./dbp-audit.json?v=20261009-dbp-audit-v1',{cache:'no-cache'});if(!response.ok)throw new Error(`Audit request returned ${response.status}`);audit=await response.json();if(!audit||typeof audit!=='object'||!audit.summary||!audit.measurement||!audit.environment)throw new Error('The audit JSON does not match the required top-level schema.');initialize();
+  } catch(error) {
+    $('load-error').hidden=false;$('load-error').textContent=`The independent DBP audit is not available yet. No completed result is inferred. ${error.message}`;$('audit-state').textContent='Unavailable';$('audit-state').className='status-chip status-incomplete';$('audit-generated').textContent='dbp-audit.json was not loaded';$('audit-table').querySelector('tbody').innerHTML='<tr><td colspan="12" class="empty-cell">Audit results unavailable.</td></tr>';$('scope-validation').textContent='The historical leaderboard remains unchanged.';
+  }
+}
+if(typeof document!=='undefined'){setupTheme();loadAudit();}
+if(typeof module!=='undefined'&&module.exports)module.exports={auditValidationErrors,normalizeColumn,normalizeDatasetReceipt,summaryObservation};

dbp-audit.json

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

dbp-audit.schema.json

@@ -0,0 +1,353 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "dbp-audit.schema.json",
+  "title": "THULab DBP native-float full-wire audit",
+  "description": "Independent DBF1/DBF2 diagnostic results. These rows do not replace or participate in the historical leaderboard.",
+  "type": "object",
+  "required": [
+    "schema_version",
+    "status",
+    "summary",
+    "measurement",
+    "environment",
+    "runtimes",
+    "datasets",
+    "columns",
+    "evidence"
+  ],
+  "properties": {
+    "schema_version": {"const": "dbp-native-float-audit-v1"},
+    "status": {"enum": ["incomplete", "pending", "running", "partial", "complete", "failed"]},
+    "generated_at": {"type": ["string", "null"]},
+    "summary": {
+      "type": "object",
+      "required": [
+        "dataset_receipt_count",
+        "measured_dataset_count",
+        "n_a_dataset_count",
+        "schema_aggregate_count",
+        "nonempty_aggregate_count",
+        "n_a_aggregate_count"
+      ],
+      "properties": {
+        "dataset_receipt_count": {"type": "integer", "minimum": 0},
+        "measured_dataset_count": {"type": "integer", "minimum": 0},
+        "n_a_dataset_count": {"type": "integer", "minimum": 0},
+        "schema_aggregate_count": {"type": "integer", "minimum": 0},
+        "nonempty_aggregate_count": {"type": "integer", "minimum": 0},
+        "n_a_aggregate_count": {"type": "integer", "minimum": 0}
+      },
+      "additionalProperties": true
+    },
+    "measurement": {
+      "type": "object",
+      "required": [
+        "context",
+        "repeats",
+        "warmup_blocks",
+        "header_bytes_per_block",
+        "encode_boundary",
+        "decode_boundary",
+        "ranking_integration"
+      ],
+      "properties": {
+        "context": {"type": "string"},
+        "repeats": {"type": "integer", "minimum": 1},
+        "warmup_blocks": {"type": "integer", "minimum": 0},
+        "header_bytes_per_block": {"const": 10},
+        "encode_boundary": {"type": "string"},
+        "decode_boundary": {"type": "string"},
+        "ranking_integration": {"const": "separate"},
+        "notes": {"type": "array", "items": {"type": "string"}}
+      },
+      "additionalProperties": true
+    },
+    "environment": {
+      "type": "object",
+      "properties": {
+        "host": {"type": ["string", "null"]},
+        "hardware": {"type": ["string", "object", "null"]},
+        "cpu": {"type": ["string", "object", "null"]},
+        "os": {"type": ["string", "object", "null"]},
+        "load": {"type": ["string", "number", "object", "null"]},
+        "clock": {"type": ["string", "object", "null"]},
+        "cpu_affinity": {"type": ["string", "array", "null"]},
+        "concurrent_load": {"type": ["string", "number", "object", "null"]},
+        "shared_server": {"type": ["boolean", "null"]},
+        "captured_at": {"type": ["string", "null"]}
+      },
+      "additionalProperties": true
+    },
+    "runtimes": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["runtime", "status"],
+        "properties": {
+          "runtime": {"enum": ["cpp", "java", "python"]},
+          "status": {"$ref": "#/$defs/status"},
+          "version": {"type": ["string", "null"]},
+          "source_sha256": {"$ref": "#/$defs/nullableSha256"},
+          "result_sha256": {"$ref": "#/$defs/nullableSha256"},
+          "message": {"type": ["string", "null"]}
+        },
+        "additionalProperties": true
+      }
+    },
+    "datasets": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["dataset", "runtime", "status"],
+        "properties": {
+          "dataset": {"type": "string", "minLength": 1},
+          "runtime": {"enum": ["cpp", "java", "python"]},
+          "label": {"type": ["string", "null"]},
+          "status": {"$ref": "#/$defs/status"},
+          "reason": {"type": ["string", "null"]},
+          "receipt_sha256": {"$ref": "#/$defs/nullableSha256"},
+          "schema_aggregate_count": {"type": "integer", "minimum": 0},
+          "nonempty_aggregate_count": {"type": "integer", "minimum": 0},
+          "n_a_aggregate_count": {"type": "integer", "minimum": 0}
+        },
+        "additionalProperties": true
+      }
+    },
+    "columns": {
+      "type": "array",
+      "items": {"$ref": "#/$defs/columnResult"}
+    },
+    "evidence": {
+      "type": "object",
+      "properties": {
+        "scope_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "source_column_inventory_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "runtime_artifact_manifest_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "campaign_binding_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "frame_verification_receipt_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "compact_collection_receipt_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "input_scope_receipt_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "campaign_run_receipt_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "campaign_progress_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "environment_receipt_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "source_evidence_chain_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "runtime_result_chain_sha256": {
+          "type": "object",
+          "properties": {
+            "cpp": {"$ref": "#/$defs/nullableSha256"},
+            "java": {"$ref": "#/$defs/nullableSha256"},
+            "python": {"$ref": "#/$defs/nullableSha256"}
+          },
+          "additionalProperties": false
+        }
+      },
+      "additionalProperties": true
+    }
+  },
+  "allOf": [
+    {
+      "if": {"properties": {"status": {"const": "complete"}}, "required": ["status"]},
+      "then": {
+        "properties": {
+          "summary": {
+            "properties": {
+              "dataset_receipt_count": {"const": 169},
+              "measured_dataset_count": {"const": 162},
+              "n_a_dataset_count": {"const": 7},
+              "schema_aggregate_count": {"const": 4190},
+              "nonempty_aggregate_count": {"const": 4096},
+              "n_a_aggregate_count": {"const": 94}
+            }
+          },
+          "measurement": {
+            "properties": {
+              "repeats": {"const": 1},
+              "warmup_blocks": {"const": 20},
+              "header_bytes_per_block": {"const": 10}
+            }
+          },
+          "environment": {
+            "required": ["hardware", "cpu", "clock", "cpu_affinity", "concurrent_load", "shared_server", "captured_at"],
+            "properties": {
+              "shared_server": {"const": true},
+              "cpu": {
+                "type": "object",
+                "required": ["passed_receipts_at_capture"],
+                "properties": {"passed_receipts_at_capture": {"const": 169}}
+              }
+            }
+          },
+          "runtimes": {
+            "minItems": 3,
+            "maxItems": 3,
+            "items": {
+              "allOf": [
+                {"$ref": "#/$defs/runtimeStatus"},
+                {"properties": {"status": {"const": "complete"}, "result_sha256": {"$ref": "#/$defs/sha256"}}, "required": ["result_sha256"]}
+              ]
+            },
+            "allOf": [
+              {"contains": {"properties": {"runtime": {"const": "cpp"}}, "required": ["runtime"]}, "minContains": 1, "maxContains": 1},
+              {"contains": {"properties": {"runtime": {"const": "java"}}, "required": ["runtime"]}, "minContains": 1, "maxContains": 1},
+              {"contains": {"properties": {"runtime": {"const": "python"}}, "required": ["runtime"]}, "minContains": 1, "maxContains": 1}
+            ]
+          },
+          "datasets": {
+            "minItems": 507,
+            "maxItems": 507,
+            "items": {
+              "allOf": [
+                {"$ref": "#/$defs/datasetReceipt"},
+                {"properties": {"status": {"enum": ["ok", "n_a"]}, "receipt_sha256": {"$ref": "#/$defs/sha256"}}, "required": ["receipt_sha256", "schema_aggregate_count", "nonempty_aggregate_count", "n_a_aggregate_count"]}
+              ]
+            }
+          },
+          "columns": {
+            "minItems": 12570,
+            "maxItems": 12570,
+            "items": {
+              "allOf": [
+                {"$ref": "#/$defs/columnResult"},
+                {
+                  "properties": {
+                    "status": {"enum": ["ok", "n_a"]},
+                    "aggregate_id": {"type": "string", "minLength": 1},
+                    "frame_sequence_sha256": {"$ref": "#/$defs/sha256"},
+                    "expected_sequence_chain_sha256": {"$ref": "#/$defs/sha256"},
+                    "result_sha256": {"$ref": "#/$defs/sha256"},
+                    "receipt_sha256": {"$ref": "#/$defs/sha256"},
+                    "source_manifest_receipt_sha256": {"$ref": "#/$defs/sha256"},
+                    "source_aggregates_sha256": {"$ref": "#/$defs/sha256"},
+                    "source_blocks_sha256": {"$ref": "#/$defs/sha256"},
+                    "source_block_catalog_sha256": {"$ref": "#/$defs/sha256"},
+                    "runtime_artifact_manifest_sha256": {"$ref": "#/$defs/sha256"},
+                    "source_column_inventory_sha256": {"$ref": "#/$defs/sha256"},
+                    "scope_sha256": {"$ref": "#/$defs/sha256"}
+                  },
+                  "required": ["aggregate_id", "width", "max_point", "encode_ns", "decode_ns", "frame_sequence_sha256", "expected_sequence_chain_sha256", "result_sha256", "receipt_sha256", "source_manifest_receipt_sha256", "source_aggregates_sha256", "source_blocks_sha256", "source_block_catalog_sha256", "runtime_artifact_manifest_sha256", "source_column_inventory_sha256", "scope_sha256"]
+                }
+              ]
+            }
+          },
+          "evidence": {
+            "required": ["scope_sha256", "source_column_inventory_sha256", "runtime_artifact_manifest_sha256", "campaign_binding_sha256", "frame_verification_receipt_sha256", "compact_collection_receipt_sha256", "input_scope_receipt_sha256", "campaign_run_receipt_sha256", "campaign_progress_sha256", "environment_receipt_sha256", "source_evidence_chain_sha256", "runtime_result_chain_sha256"],
+            "properties": {
+              "scope_sha256": {"$ref": "#/$defs/sha256"},
+              "source_column_inventory_sha256": {"$ref": "#/$defs/sha256"},
+              "runtime_artifact_manifest_sha256": {"$ref": "#/$defs/sha256"},
+              "campaign_binding_sha256": {"$ref": "#/$defs/sha256"},
+              "frame_verification_receipt_sha256": {"$ref": "#/$defs/sha256"},
+              "compact_collection_receipt_sha256": {"$ref": "#/$defs/sha256"},
+              "input_scope_receipt_sha256": {"$ref": "#/$defs/sha256"},
+              "campaign_run_receipt_sha256": {"$ref": "#/$defs/sha256"},
+              "campaign_progress_sha256": {"$ref": "#/$defs/sha256"},
+              "environment_receipt_sha256": {"$ref": "#/$defs/sha256"},
+              "source_evidence_chain_sha256": {"$ref": "#/$defs/sha256"},
+              "runtime_result_chain_sha256": {
+                "required": ["cpp", "java", "python"],
+                "properties": {"cpp": {"$ref": "#/$defs/sha256"}, "java": {"$ref": "#/$defs/sha256"}, "python": {"$ref": "#/$defs/sha256"}}
+              }
+            }
+          }
+        }
+      }
+    }
+  ],
+  "$defs": {
+    "status": {
+      "enum": ["incomplete", "pending", "running", "partial", "complete", "ok", "passed", "n_a", "failed", "skipped"]
+    },
+    "nullableSha256": {
+      "type": ["string", "null"],
+      "pattern": "^[0-9a-f]{64}$"
+    },
+    "sha256": {"type": "string", "pattern": "^[0-9a-f]{64}$"},
+    "runtimeStatus": {
+      "type": "object",
+      "required": ["runtime", "status"],
+      "properties": {
+        "runtime": {"enum": ["cpp", "java", "python"]},
+        "status": {"$ref": "#/$defs/status"},
+        "version": {"type": ["string", "null"]},
+        "result_sha256": {"$ref": "#/$defs/nullableSha256"}
+      },
+      "additionalProperties": true
+    },
+    "datasetReceipt": {
+      "type": "object",
+      "required": ["dataset", "runtime", "status"],
+      "properties": {
+        "dataset": {"type": "string", "minLength": 1},
+        "runtime": {"enum": ["cpp", "java", "python"]},
+        "status": {"$ref": "#/$defs/status"},
+        "receipt_sha256": {"$ref": "#/$defs/nullableSha256"}
+      },
+      "additionalProperties": true
+    },
+    "metric": {"type": ["number", "null"], "minimum": 0},
+    "columnResult": {
+      "type": "object",
+      "required": [
+        "status",
+        "runtime",
+        "dataset",
+        "column",
+        "dtype",
+        "native_bytes",
+        "frame_bytes",
+        "compression_rate",
+        "encode_ns_per_value",
+        "decode_ns_per_value",
+        "blocks",
+        "scaled_blocks",
+        "raw_blocks",
+        "rows",
+        "valid_count",
+        "missing_count",
+        "validity_bytes",
+        "header_bytes",
+        "verified_values"
+      ],
+      "properties": {
+        "status": {"$ref": "#/$defs/status"},
+        "runtime": {"enum": ["cpp", "java", "python"]},
+        "dataset": {"type": "string", "minLength": 1},
+        "column": {"type": "string", "minLength": 1},
+        "aggregate_id": {"type": ["string", "null"]},
+        "width": {"type": "integer", "enum": [4, 8]},
+        "max_point": {"type": "integer", "minimum": 0},
+        "encode_ns": {"type": "integer", "minimum": 0},
+        "decode_ns": {"type": "integer", "minimum": 0},
+        "dtype": {"enum": ["float32", "float64"]},
+        "native_bytes": {"type": "integer", "minimum": 0},
+        "frame_bytes": {"type": "integer", "minimum": 0},
+        "compression_rate": {"$ref": "#/$defs/metric"},
+        "encode_ns_per_value": {"$ref": "#/$defs/metric"},
+        "decode_ns_per_value": {"$ref": "#/$defs/metric"},
+        "blocks": {"type": "integer", "minimum": 0},
+        "scaled_blocks": {"type": "integer", "minimum": 0},
+        "raw_blocks": {"type": "integer", "minimum": 0},
+        "rows": {"type": "integer", "minimum": 0},
+        "valid_count": {"type": "integer", "minimum": 0},
+        "missing_count": {"type": "integer", "minimum": 0},
+        "verified_values": {"type": "integer", "minimum": 0},
+        "validity_bytes": {"type": "integer", "minimum": 0},
+        "header_bytes": {"type": "integer", "minimum": 0},
+        "frame_sequence_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "expected_sequence_chain_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "result_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "receipt_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "source_manifest_receipt_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "source_aggregates_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "source_blocks_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "source_block_catalog_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "runtime_artifact_manifest_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "source_column_inventory_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "scope_sha256": {"$ref": "#/$defs/nullableSha256"},
+        "message": {"type": ["string", "null"]}
+      },
+      "additionalProperties": true
+    }
+  },
+  "additionalProperties": true
+}

export_results.py

@@ -470,13 +470,14 @@ def main() -> int:
             "selection_note": "Configuration views retain measured configurations passing the project's method-name filter. This does not certify every result as lossless. Family views choose the lowest-rate configuration independently for each dataset, scope, and runtime.",
             "method_audits": {
                 "DBP": {
-                    "audited_at": "2026-10-08",
-                    "label": "Kernel measurements",
-                    "implementation": "Project DBP encodes deltas with ZigZag and ULEB128; it is not Parquet miniblock bit-packing.",
-                    "timing": "Float preparation/scaling is outside the reported codec timer.",
-                    "storage": "Reported float payload sizes omit the scale/mode metadata needed for complete reconstruction.",
-                    "roundtrip": "Integer payload round-trip checks do not establish end-to-end bit-exact float reconstruction. Current Java/Python catalog scaling paths lack a bit-exact guard; current C++ has an exact-scaling check and IEEE-bit fallback, but old reports do not identify the exact executable revision.",
-                    "comparison": "Compared methods may use different columns or point counts. Check the per-dataset original byte counts before comparing results.",
+                    "audited_at": "2026-10-09",
+                    "label": "Historical kernel measurements",
+                    "full_wire_audit_url": "./dbp-audit.html",
+                    "implementation": "The historical project DBP snapshot encodes deltas with ZigZag and ULEB128. The separate DBF1/DBF2 native-float remeasurement adds a complete reconstruction header and a bit-exact scale-or-IEEE mode.",
+                    "timing": "Historical leaderboard float preparation/scaling is outside the reported codec timer. The separate native-float audit measures scale selection, conversion, complete frame encoding, parsing and inverse reconstruction within their respective timers.",
+                    "storage": "Historical leaderboard float payload sizes omit reconstruction scale/mode metadata. The separate native-float audit counts the entire DBF1/DBF2 frame, including its 10-byte header per block; validity sidecars are recorded separately.",
+                    "roundtrip": "Historical integer-payload checks do not certify those leaderboard float rows. The new native-float audit verifies every valid value against its original float32 or float64 bit pattern and compares complete frame hashes across C++, Java and Python.",
+                    "comparison": "Historical and newly frozen typed inputs have different column and dtype scopes. The native-float audit is published separately and does not enter the historical Overall scores or Average Rank.",
                 }
             },
             "notes": [

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-scope169-v1">
-  <script src="app.js?v=20261008-scope169-v1" type="module"></script>
+  <link rel="stylesheet" href="style.css?v=20261009-dbp-audit-v1">
+  <script src="app.js?v=20261009-dbp-audit-v1" type="module"></script>
 </head>
 <body>
   <a class="skip-link" href="#content">Skip to results</a>

manifest.json

@@ -28,8 +28,60 @@
     "source_report_file_count": 108
   },
   "data_file": "data.json",
-  "data_sha256": "7618054cc2699fd855f673bfd41f7f5b94ee466028043bc669e457ead1984f63",
+  "data_sha256": "7b5bd2bf29b7794a6b08e545cbc2a9244f7a0efcf9bad68e6e8355455327ca37",
   "dataset_catalog_sha256": "a5930a8a0cd52cfbd15c176e8384184fbbdb8778b67ee8e3fe923d5c00cfac82",
+  "dbp_native_float_audit": {
+    "files": {
+      "dbp-audit-build-receipt.json": {
+        "bytes": 5292,
+        "sha256": "211958f34d280daea3ab6dde8c56ca5b4207cc78ad767a22a37910dc3b5cb892"
+      },
+      "dbp-audit-columns.csv": {
+        "bytes": 11753491,
+        "sha256": "ed617bab971dfaa2e398aca2ad9fb73ee5b0d5b8c614667d3c95fa3e02247d7f"
+      },
+      "dbp-audit.html": {
+        "bytes": 7245,
+        "sha256": "aca2a426b2a4fa56eb59ca2bfbc164ce9096ff13deb2bd5479e91c16a407b059"
+      },
+      "dbp-audit.js": {
+        "bytes": 25037,
+        "sha256": "9ae0d2a00500b1be7433981527618c0c31702b075d51387cf816fb3166693338"
+      },
+      "dbp-audit.json": {
+        "bytes": 24243804,
+        "sha256": "febe0d4494cf3778bb3e386ac8674f24406e29d1d7d9b47bd834b332b0e201fb"
+      },
+      "dbp-audit.schema.json": {
+        "bytes": 15210,
+        "sha256": "e3409dbf44c07b9edd6e855980ad56e70a526b2940df0a0e20e4f7c14415d10d"
+      }
+    },
+    "scope": "separate frozen typed data; excluded from historical Overall scores and Average Rank",
+    "source_scope_sha256": "0fabc01f25d62ddb49585b3208103543b16c6e50340195360a0516411fa148b4",
+    "summary": {
+      "all_null_nonempty_aggregate_count": 92,
+      "dataset_receipt_count": 169,
+      "datasets_with_float_schema_count": 163,
+      "float32_aggregate_count": 2332,
+      "float32_native_values_bytes": 2111592024,
+      "float64_aggregate_count": 1858,
+      "float64_native_values_bytes": 7636696656,
+      "header_bytes": 54052230,
+      "logical_blocks": 5405223,
+      "measured_dataset_count": 162,
+      "n_a_aggregate_count": 94,
+      "n_a_dataset_count": 7,
+      "native_values_bytes": 9748288680,
+      "no_float_schema_dataset_count": 6,
+      "nonempty_aggregate_count": 4096,
+      "schema_aggregate_count": 4190,
+      "valid_value_count": 1482485088,
+      "validity_bytes": 208277366,
+      "zero_row_aggregate_count": 2
+    },
+    "timing_context": "shared-server single-pass diagnostic"
+  },
   "excluded_content": [
     "raw datasets",
     "user uploads",

style.css

@@ -14,3 +14,6 @@
 .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}}
+.audit-notice a{font-weight:650}.documentation-action{display:inline-flex;margin-top:12px;font-size:11px}.dbp-audit-main{max-width:1440px}.audit-hero{display:flex;align-items:center;justify-content:space-between;gap:32px;padding:34px 0 24px}.audit-hero .intro-text{margin:0;max-width:820px}.audit-state-card{flex:0 0 230px;padding:16px;border:1px solid var(--line);border-radius:var(--radius);background:var(--surface)}.audit-state-card>span,.audit-state-card>small{display:block;color:var(--muted);font-size:10px}.audit-state-card>strong{display:inline-block;margin:7px 0}.status-chip{padding:3px 8px;border-radius:999px;border:1px solid var(--line);background:var(--soft);font-size:10px;line-height:1.4;text-transform:uppercase;letter-spacing:.05em}.status-complete,.status-ok,.status-passed{border-color:var(--accent);background:var(--accent-soft);color:var(--accent)}.status-failed{border-color:#b34938;background:#b3493818;color:#b34938}.status-incomplete,.status-pending,.status-running,.status-partial,.status-skipped,.status-n-a,.status-na,.status-unknown{color:var(--muted)}.audit-scope-notice{margin:0 0 26px}.audit-scope-notice p{max-width:110ch;margin:6px 0 0}.section-heading{display:flex;align-items:end;justify-content:space-between;gap:24px;margin:24px 0 12px}.section-heading>div:first-child{min-width:0}.audit-summary{display:grid;grid-template-columns:repeat(6,minmax(0,1fr));gap:1px;border:1px solid var(--line);border-radius:var(--radius);overflow:hidden;background:var(--line)}.audit-summary>div{padding:14px;background:var(--surface);text-align:center}.audit-summary strong{display:block;font-size:22px;line-height:1.2;font-variant-numeric:tabular-nums}.audit-summary span{display:block;margin-top:5px;color:var(--muted);font-size:10px}.audit-meta-grid{display:grid;grid-template-columns:1fr 1fr;gap:18px;margin:24px 0}.audit-meta-grid article{padding:18px;border:1px solid var(--line);border-radius:var(--radius);background:var(--surface)}.audit-meta-grid h2{margin-bottom:12px}.audit-definitions{display:grid;grid-template-columns:minmax(120px,.45fr) 1fr;margin:0}.audit-definitions dt,.audit-definitions dd{padding:7px 0;border-top:1px solid var(--line);font-size:11px;overflow-wrap:anywhere}.audit-definitions dt{color:var(--muted);font-weight:600}.audit-definitions dd{margin:0}.runtime-status-grid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:12px}.runtime-status-card{padding:15px;border:1px solid var(--line);border-radius:var(--radius);background:var(--surface)}.runtime-status-card header{display:flex;align-items:center;justify-content:space-between;gap:12px}.runtime-status-card h3{margin:0;font-size:15px}.runtime-status-card p{margin:8px 0 0;color:var(--muted);font-size:11px;overflow-wrap:anywhere}.audit-results{margin-top:26px}.audit-filters{display:grid;grid-template-columns:.8fr .9fr 1fr 1.8fr;gap:12px;padding:15px;border:1px solid var(--line);border-radius:var(--radius);background:var(--soft)}.audit-table-wrap{max-height:610px}.audit-table-wrap thead th:nth-child(3),.audit-table-wrap thead th:nth-child(4),.audit-table-wrap tbody td:nth-child(3),.audit-table-wrap tbody td:nth-child(4){text-align:left}.audit-table-wrap td{font-size:11px}.audit-table-wrap .mode-count{display:block;color:var(--muted);font-size:9px}.audit-pagination{display:flex;align-items:center;justify-content:center;gap:14px;padding:12px}.audit-pagination span{color:var(--muted);font-size:11px}.dataset-receipt-grid{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px;max-height:460px;overflow:auto;padding-right:5px}.dataset-receipt-card{min-width:0;padding:10px;border:1px solid var(--line);border-radius:6px;background:var(--surface)}.dataset-receipt-card header{display:flex;align-items:start;justify-content:space-between;gap:8px}.dataset-receipt-card strong{display:block;font-size:11px;overflow-wrap:anywhere}.dataset-receipt-card small{display:block;color:var(--muted);font-size:9px}.dataset-receipt-card p{margin:6px 0 0;color:var(--muted);font-size:9px;line-height:1.45;overflow-wrap:anywhere}.audit-reading-note{max-width:100ch;margin:30px 0}.audit-reading-note p{color:var(--muted);font-size:12px}.audit-validation-error{color:#b34938}.audit-validation-ok{color:var(--muted)}
+@media(max-width:1000px){.audit-summary{grid-template-columns:repeat(3,1fr)}.audit-filters{grid-template-columns:repeat(2,1fr)}.dataset-receipt-grid{grid-template-columns:repeat(2,minmax(0,1fr))}}
+@media(max-width:768px){.audit-hero{align-items:stretch;flex-direction:column;padding-top:24px}.audit-state-card{flex:auto;width:100%}.audit-summary{grid-template-columns:repeat(2,1fr)}.audit-meta-grid,.runtime-status-grid,.audit-filters,.dataset-receipt-grid{grid-template-columns:1fr}.section-heading{align-items:stretch;flex-direction:column;gap:10px}.audit-definitions{grid-template-columns:1fr}.audit-definitions dd{padding-top:0;border-top:0}.audit-results .toolbar-actions{width:100%}.audit-results .toolbar-actions button{flex:1}}