Update nine scaled integer codecs on the current 135-dataset benchmark

Import 1,206 completed float-column jobs and 27,522 column measurements; retain existing integer results and historical outputs. Partial numeric support is explicit, and mixed-host timing remains unavailable. Refresh full and compact data, evidence, and cache bindings.

FLOAT_SCALING9_SITE_ACCEPTANCE.json

@@ -0,0 +1,251 @@
+{
+  "admission": {
+    "float_timing": "accepted only over the exact supported numeric subset within the server-192 profile as equal-column arithmetic mean of per-column ns/point",
+    "mixed_overall_timing": "unavailable; server-166 integer and server-192 float timing are never merged",
+    "rate_bytes": "accepted exact P172B861 complete-frame bytes over the exact supported numeric subset; partial rows are never described as full-workload coverage",
+    "unsupported_and_NA": "explicit states retained; no zero-valued results fabricated"
+  },
+  "created_at": "2026-10-15T03:15:05.494450+00:00",
+  "producer_terminal_status_preserved": "completed_unreviewed",
+  "public_overlay": {
+    "file": "float-scaling9-dataset-overlays.jsonl.gz",
+    "rows": 1206,
+    "sha256": "027760f75a88dd8b91b658797855c3c5339ac74c7ef394105a37e4912f25afc7"
+  },
+  "schema": "compressionbenchmark-float-scaling9-site-acceptance-v1",
+  "scope": {
+    "column_method_count": 27522,
+    "current_measured_dataset_count": 135,
+    "dataset_count_with_float": 134,
+    "dataset_method_count": 1206,
+    "method_count": 9,
+    "method_ids": [
+      "2DIFF",
+      "BOS",
+      "DBP",
+      "FastPFor",
+      "LECO",
+      "REGER",
+      "RLBE",
+      "SVB",
+      "Simple8b"
+    ],
+    "pure_integer_dataset_retained": "NYC_Yellow_Taxi_Trip"
+  },
+  "status": "accepted_for_rate_and_own_profile_timing",
+  "validation": {
+    "augmentation": null,
+    "column_method_count": 27522,
+    "cross_host_timing": "forbidden",
+    "dataset_count": 134,
+    "dataset_method_count": 1206,
+    "failed_columns": 0,
+    "failed_jobs": 0,
+    "method_count": 9,
+    "runtime_binary_sha256": "0558378c92fe855f666da67d4f712043df084838619f35af9e2ae40dc183c704",
+    "source_file_sha256": {
+      "CAMPAIGN_TERMINAL.json": "e0aa76d39ffb9d132b60f5075ac6f92df8c85a03c4d437d6097a9bd09e2a476f",
+      "DELIVERY_RECEIPT.json": "57ec6d83bd13e8e1312ba77266119a401e2fbfb37ede28170e753557187411ef",
+      "FLOAT_COLUMN_RESULTS.jsonl": "43884b68676c265c99e7ea73d5d026aba939c04f50a1df4d29d570d285577ab2",
+      "FLOAT_DATASET_METHOD_OVERLAY.jsonl": "77f016e4fe87f81a178749ba315627089420b23dd27dd26aa1ac50f09415eda5",
+      "SOURCE_BINDINGS.json": "b1e392e009b379e85b20c5d701954482b16873a2de536bb506f86da7dc61d59f",
+      "START.json": "d6b85101ef0960d56cf9ecd202f63ec8117630589adb8818160530583dfebe2d",
+      "SUMMARY.json": "d9e97cff8707ab20cf9f28e33b8dbf9dbfeee9edf224edfc66b89662587a031f"
+    },
+    "support_semantics": {
+      "by_method": {
+        "2DIFF": {
+          "full_numeric_workload_dataset_count_with_NYC": 118,
+          "measurement_row_dataset_count_with_NYC": 135,
+          "partial_numeric_dataset_count": 17,
+          "partial_numeric_datasets": [
+            "Bar-Crawl",
+            "Romance",
+            "current_velocity",
+            "eea_pm25_forecasting",
+            "faang_engineered_time_series_features_2013_2025",
+            "goes_omni_electron_flux_forecasting",
+            "hourly-stock-data-2023",
+            "kdd_cup_2018",
+            "kraken-trading-data",
+            "multi_model_trading_data",
+            "ooni_censorship_historical",
+            "orbital_chaos_nasa_ssc",
+            "reg_forecasting_v2",
+            "stock_dataset",
+            "timeseries_1mn_stocks",
+            "tourism_residuals",
+            "wind_farms_minutely"
+          ],
+          "unsupported_valid_value_count": 59930570
+        },
+        "BOS": {
+          "full_numeric_workload_dataset_count_with_NYC": 123,
+          "measurement_row_dataset_count_with_NYC": 135,
+          "partial_numeric_dataset_count": 12,
+          "partial_numeric_datasets": [
+            "Bar-Crawl",
+            "current_velocity",
+            "eea_pm25_forecasting",
+            "goes_omni_electron_flux_forecasting",
+            "kdd_cup_2018",
+            "kraken-trading-data",
+            "ooni_censorship_historical",
+            "orbital_chaos_nasa_ssc",
+            "reg_forecasting_v2",
+            "stock_dataset",
+            "timeseries_1mn_stocks",
+            "wind_farms_minutely"
+          ],
+          "unsupported_valid_value_count": 19762417
+        },
+        "DBP": {
+          "full_numeric_workload_dataset_count_with_NYC": 123,
+          "measurement_row_dataset_count_with_NYC": 135,
+          "partial_numeric_dataset_count": 12,
+          "partial_numeric_datasets": [
+            "Bar-Crawl",
+            "current_velocity",
+            "eea_pm25_forecasting",
+            "goes_omni_electron_flux_forecasting",
+            "kdd_cup_2018",
+            "kraken-trading-data",
+            "ooni_censorship_historical",
+            "orbital_chaos_nasa_ssc",
+            "reg_forecasting_v2",
+            "stock_dataset",
+            "timeseries_1mn_stocks",
+            "wind_farms_minutely"
+          ],
+          "unsupported_valid_value_count": 19762417
+        },
+        "FastPFor": {
+          "full_numeric_workload_dataset_count_with_NYC": 123,
+          "measurement_row_dataset_count_with_NYC": 135,
+          "partial_numeric_dataset_count": 12,
+          "partial_numeric_datasets": [
+            "Bar-Crawl",
+            "current_velocity",
+            "eea_pm25_forecasting",
+            "goes_omni_electron_flux_forecasting",
+            "kdd_cup_2018",
+            "kraken-trading-data",
+            "ooni_censorship_historical",
+            "orbital_chaos_nasa_ssc",
+            "reg_forecasting_v2",
+            "stock_dataset",
+            "timeseries_1mn_stocks",
+            "wind_farms_minutely"
+          ],
+          "unsupported_valid_value_count": 19762417
+        },
+        "LECO": {
+          "full_numeric_workload_dataset_count_with_NYC": 123,
+          "measurement_row_dataset_count_with_NYC": 135,
+          "partial_numeric_dataset_count": 12,
+          "partial_numeric_datasets": [
+            "Bar-Crawl",
+            "current_velocity",
+            "eea_pm25_forecasting",
+            "goes_omni_electron_flux_forecasting",
+            "kdd_cup_2018",
+            "kraken-trading-data",
+            "ooni_censorship_historical",
+            "orbital_chaos_nasa_ssc",
+            "reg_forecasting_v2",
+            "stock_dataset",
+            "timeseries_1mn_stocks",
+            "wind_farms_minutely"
+          ],
+          "unsupported_valid_value_count": 19762417
+        },
+        "REGER": {
+          "full_numeric_workload_dataset_count_with_NYC": 123,
+          "measurement_row_dataset_count_with_NYC": 135,
+          "partial_numeric_dataset_count": 12,
+          "partial_numeric_datasets": [
+            "Bar-Crawl",
+            "current_velocity",
+            "eea_pm25_forecasting",
+            "goes_omni_electron_flux_forecasting",
+            "kdd_cup_2018",
+            "kraken-trading-data",
+            "ooni_censorship_historical",
+            "orbital_chaos_nasa_ssc",
+            "reg_forecasting_v2",
+            "stock_dataset",
+            "timeseries_1mn_stocks",
+            "wind_farms_minutely"
+          ],
+          "unsupported_valid_value_count": 19762417
+        },
+        "RLBE": {
+          "full_numeric_workload_dataset_count_with_NYC": 123,
+          "measurement_row_dataset_count_with_NYC": 135,
+          "partial_numeric_dataset_count": 12,
+          "partial_numeric_datasets": [
+            "Bar-Crawl",
+            "current_velocity",
+            "eea_pm25_forecasting",
+            "goes_omni_electron_flux_forecasting",
+            "kdd_cup_2018",
+            "kraken-trading-data",
+            "ooni_censorship_historical",
+            "orbital_chaos_nasa_ssc",
+            "reg_forecasting_v2",
+            "stock_dataset",
+            "timeseries_1mn_stocks",
+            "wind_farms_minutely"
+          ],
+          "unsupported_valid_value_count": 19762417
+        },
+        "SVB": {
+          "full_numeric_workload_dataset_count_with_NYC": 123,
+          "measurement_row_dataset_count_with_NYC": 135,
+          "partial_numeric_dataset_count": 12,
+          "partial_numeric_datasets": [
+            "Bar-Crawl",
+            "current_velocity",
+            "eea_pm25_forecasting",
+            "goes_omni_electron_flux_forecasting",
+            "kdd_cup_2018",
+            "kraken-trading-data",
+            "ooni_censorship_historical",
+            "orbital_chaos_nasa_ssc",
+            "reg_forecasting_v2",
+            "stock_dataset",
+            "timeseries_1mn_stocks",
+            "wind_farms_minutely"
+          ],
+          "unsupported_valid_value_count": 19762417
+        },
+        "Simple8b": {
+          "full_numeric_workload_dataset_count_with_NYC": 123,
+          "measurement_row_dataset_count_with_NYC": 135,
+          "partial_numeric_dataset_count": 12,
+          "partial_numeric_datasets": [
+            "Bar-Crawl",
+            "current_velocity",
+            "eea_pm25_forecasting",
+            "goes_omni_electron_flux_forecasting",
+            "kdd_cup_2018",
+            "kraken-trading-data",
+            "ooni_censorship_historical",
+            "orbital_chaos_nasa_ssc",
+            "reg_forecasting_v2",
+            "stock_dataset",
+            "timeseries_1mn_stocks",
+            "wind_farms_minutely"
+          ],
+          "unsupported_valid_value_count": 19762417
+        }
+      },
+      "coverage_note": "135/135 is measurement-row dataset coverage after retaining pure-integer NYC; it is not full numeric workload coverage for partial_numeric pairs.",
+      "full_numeric_workload_pair_count": 1093,
+      "measurement_row_pair_count": 1206,
+      "partial_numeric_pair_count": 113,
+      "unsupported_valid_value_count": 218029906
+    },
+    "timing_contract": "W1/R3/T1/cold2; per-dataset website ns/point is the arithmetic mean of per-column median(aligned block sums)/valid numeric point count; compression includes frozen whole-column precision derivation"
+  }
+}

FLOAT_SCALING9_SITE_INTEGRATION.json

@@ -0,0 +1,90 @@
+{
+  "created_at": "2026-10-15T03:15:12.465572+00:00",
+  "files": {
+    "FLOAT_SCALING9_SITE_ACCEPTANCE.json": {
+      "bytes": 9794,
+      "sha256": "1a9cbcd4a2b38e770047734fa41f4b61c8f4919778fa80c53e11778a1e0db9e4"
+    },
+    "app.js": {
+      "bytes": 68670,
+      "sha256": "bb92e7beda5f51bda2251e3b82ba324f38f9eed4b7b0e0edb35921d6d6c692f1"
+    },
+    "build_float_scaling9_site.py": {
+      "bytes": 48477,
+      "sha256": "65a215c0c6a2089019701149d44c0a21e48eaae77aa0c33118aad2d57ada54a3"
+    },
+    "cpp-latest-view.json": {
+      "bytes": 29094332,
+      "sha256": "564b8f7760a6336e93bd0d69601e74ada9819b361dc2464d768689af0d287cbd"
+    },
+    "data.json": {
+      "bytes": 141118632,
+      "sha256": "3c66633b2d58b126edfad8afe173caf1f53fbcdb6f7b205c3d51b42dfc75a241"
+    },
+    "float-scaling9-dataset-overlays.jsonl.gz": {
+      "bytes": 183242,
+      "sha256": "027760f75a88dd8b91b658797855c3c5339ac74c7ef394105a37e4912f25afc7"
+    },
+    "index.html": {
+      "bytes": 17794,
+      "sha256": "2dac927226504d65ca4def06adb76154e737e29a16ae6ac7db64f478d78af5ce"
+    },
+    "manifest.json": {
+      "bytes": 87892,
+      "sha256": "5d2d09c0f4f0f7b057fe3733e737b4b4dd9be06e4c524199167f30fe9c26c3ee"
+    },
+    "ui-data.json": {
+      "bytes": 9217223,
+      "sha256": "c3c7103e47e0d61225839d9fd63f1b9d3757cf519a578c41ef9c81be46f3534d"
+    }
+  },
+  "final_dataset_result_count": 94971,
+  "historical_dataset_results_canonical_sha256": "2b850f45f6cf45fee3680fb50b69190379dbd11991e82ae8131d06e5b94d021a",
+  "new_dataset_result_count": 2412,
+  "old_dataset_result_count": 92559,
+  "page_checks_required_after_publication": [
+    "C++ overall shows 135/135 measurement-row coverage for the nine methods and separately labels partial_numeric supported-subset rows",
+    "Mixed-dataset overall rows show unavailable timing and retain both source hosts in details",
+    "Float-scope rows show server-192 provenance and exact scaling configuration",
+    "CSV keeps source profile, source host, binary/support SHA, measurement status, and timing status"
+  ],
+  "parent_revision": "86c9d336ea4b292b4b2fae7040d273fef9c58ca3",
+  "publication_file_list": [
+    "data.json",
+    "ui-data.json",
+    "cpp-latest-view.json",
+    "app.js",
+    "index.html",
+    "manifest.json",
+    "float-scaling9-dataset-overlays.jsonl.gz",
+    "FLOAT_SCALING9_SITE_ACCEPTANCE.json",
+    "build_float_scaling9_site.py",
+    "FLOAT_SCALING9_SITE_INTEGRATION.json"
+  ],
+  "schema": "compressionbenchmark-float-scaling9-site-integration-v1",
+  "scope": {
+    "measured_datasets": 135,
+    "method_dataset_pairs": 1215,
+    "methods": 9,
+    "mixed_dataset_method_pairs": 567,
+    "new_dataset_result_rows": 2412,
+    "pure_float_dataset_method_pairs": 639
+  },
+  "semantic_checks": {
+    "NYC_pure_integer_rows_unchanged": 9,
+    "app_javascript_syntax": "pass",
+    "full_numeric_workload_pairs_with_retained_NYC": 1102,
+    "index_app_cache_version": "20261015-float-scaling9-v1",
+    "measurement_row_coverage_pairs_with_retained_NYC": 1215,
+    "mixed_overall_bytes_equal_integer_plus_float": 567,
+    "mixed_overall_timing_null": 567,
+    "new_float_rows": 1206,
+    "new_overall_rows": 1206,
+    "old_rows_retained_byte_for_byte_in_canonical_order": true,
+    "partial_numeric_pairs": 113,
+    "pure_float_overall_timing_same_server192_profile": 639,
+    "unsupported_or_NA_converted_to_zero": 0,
+    "unsupported_valid_values_excluded_from_partial_rates": 218029906
+  },
+  "status": "passed_not_published"
+}

app.js

@@ -1,7 +1,7 @@
 import {FINAL160_SCOPE,FINAL160_INPUT_STATUS,applyFinal160Scope,filterFinal160Catalog,final160CoverageForFamily} from './final-scope.js?v=20261013-min128-v1';
 import {WEIGHT_TENTHS,parseWeights,addRankingMetrics} from './ranking.js?v=20261011-support-matched-v1';
 import {DEFAULT_PROFILE,profileLabel,defaultColumnVisible,metricAvailability,summarizeAvailability,visibleColumns,profileScopeText,aggregateTimedSubset,strictTimingMode} from './availability.js?v=20261013-overall-availability-v3';
-const CPP_LATEST_VIEW_SHA256='5d2a8bb4fb5c38fbc4fa130a08b7608c7568f3959ef9dd2706f245862907f90f';
+const CPP_LATEST_VIEW_SHA256='564b8f7760a6336e93bd0d69601e74ada9819b361dc2464d768689af0d287cbd';
 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;
@@ -183,7 +183,7 @@ function showMethod(method,focus=false) {
   const source=row.source.slice().sort((a,b)=>a.dataset.localeCompare(b.dataset));
   const supportDecisions=row.runtime==='cpp'?final160CoverageForFamily(cppLatestView.cpp.pair_ledger,row.family):[];
   const countSupport=predicate=>supportDecisions.filter(predicate).length;
-  const supportNote=supportDecisions.length?`C++ test scope: ${supportDecisions.length} dataset identities; ${countSupport(item=>item.status==='numeric'&&item.scopes.includes('overall'))} numeric Overall, ${countSupport(item=>item.status==='numeric'&&!item.scopes.includes('overall'))} numeric type-specific only, ${countSupport(item=>item.status==='not_applicable')} not applicable, ${countSupport(item=>item.status==='unsupported')} unsupported, ${countSupport(item=>item.status==='replacement_input_pending')} corrected-input retests pending. Type-specific results are available through the data-type filter; they are not missing experiments.`:'';
+  const supportNote=supportDecisions.length?`C++ test scope: ${supportDecisions.length} dataset identities; ${countSupport(item=>item.status==='numeric'&&item.scopes.includes('overall'))} full numeric Overall, ${countSupport(item=>item.status==='partial_numeric')} partial numeric (exact supported subset), ${countSupport(item=>item.status==='numeric'&&!item.scopes.includes('overall'))} full numeric type-specific only, ${countSupport(item=>item.status==='not_applicable')} not applicable, ${countSupport(item=>item.status==='unsupported')} unsupported, ${countSupport(item=>item.status==='replacement_input_pending')} corrected-input retests pending. Type-specific results are available through the data-type filter; they are not missing experiments.`:'';
 
   const strictCompress=metricCell(row,cols.find(column=>column.key==='compression_time')),strictDecompress=metricCell(row,cols.find(column=>column.key==='decompression_time')),subsetCompress=metricCell(row,cols.find(column=>column.key==='compression_time_timed_subset')),subsetDecompress=metricCell(row,cols.find(column=>column.key==='decompression_time_timed_subset'));
   detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${strictCompress}</strong><span>strict Compress ns/point</span></div><div><strong>${strictDecompress}</strong><span>strict Decompress ns/point</span></div><div><strong>${subsetCompress}</strong><span>Compress ns/point · timed subset</span></div><div><strong>${subsetDecompress}</strong><span>Decompress ns/point · timed subset</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${pipeline?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}${supportNote?`<p class="notice">${escape(supportNote)}</p>`:''}<p class="muted">Strict timing average: ${escape(timingLabel(row.timing_aggregation))}. Timed-subset values are shown only when every included timing row has one exact source profile, host, and timing contract; they never enter strict composite scores. Dataset metrics below retain the winning row's source family, profile, and host.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Source family</th><th>Rate ↓</th><th>Compress ns/point ↓</th><th>Decompress ns/point ↓</th><th>Timing basis</th><th>Measurement evidence</th><th>Timing profile</th><th>Selected source profile / host</th><th>Runtime / binary</th><th>Support set</th><th>Original bytes</th><th>Compressed bytes</th><th>Dataset score ↓</th><th>Dataset Rank ↓</th><th>Rank candidates</th></tr></thead><tbody>${source.map(r=>`<tr><td>${escape(r.dataset)}</td><td>${escape(r.configuration)}</td><td>${escape(r.source_family??r.family)}</td><td class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${metricCell(r,cols.find(column=>column.key==='compression_time'))}</td><td class="numeric">${metricCell(r,cols.find(column=>column.key==='decompression_time'))}</td><td>${escape(timingLabel(r.timing_aggregation))}</td><td>${escape(r.measurement_status)}</td><td>${escape(r.timing_profile_status)}</td><td class="source-code">${escape(r.source_comparison_profile??r.runtime)} / ${escape(r.source_execution_host??'source snapshot')}</td><td class="source-code">${escape(r.source_runtime)} / ${escape(String(r.binary_sha256).slice(0,16))}</td><td class="source-code">${escape(String(r.eligible_column_set_sha256).slice(0,16))}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${metricCell(r,{key:'dataset_score',digits:4})}</td><td class="numeric">${metricCell(r,{key:'dataset_rank',digits:2})}</td><td class="numeric">${fmt(r.dataset_candidate_count,0)}</td></tr>`).join('')}</tbody></table></div>`;
@@ -383,7 +383,7 @@ function decodeCompactRecord(row,index) {
   return {_compact_index:index,dataset:t.datasets[row[0]],scope:t.scopes[row[1]],runtime:t.runtimes[row[2]],comparison_profile:t.comparison_profiles[row[3]],family:t.families[row[4]],method:t.configurations[row[5]],algorithm_variant:t.configurations[row[5]],compression_rate:row[6],compression_time_ns_per_point:row[7],decompression_time_ns_per_point:row[8],original_size_bytes:row[9],compressed_size_bytes:row[10],timing_column_count:row[11],timing_aggregation:t.timing_aggregations[row[12]],eligible_column_set_sha256:t.support_sets[row[13]],measurement_status:t.measurement_statuses[row[14]],timing_profile_status:t.timing_statuses[row[15]],binary_sha256:t.binary_hashes[row[16]]};
 }
 function applyCppLatestView() {
-  if(!cppLatestView||cppLatestView.schema!=='compressionbenchmark-cpp-latest-view-v1'||cppLatestView.status!=='built_from_frozen_published_admitted_sources')throw new Error('The combined C++ selection sidecar has an invalid schema or status.');
+  if(!cppLatestView||cppLatestView.schema!=='compressionbenchmark-cpp-latest-view-v1'||cppLatestView.status!=='built_from_frozen_published_baseline_and_accepted_float_scaling9')throw new Error('The combined C++ selection sidecar has an invalid schema or status.');
   const compact=snapshot.compact_records;if(!Array.isArray(compact))throw new Error('The SHA-bound compact record table is missing.');
   if(cppLatestView.baseline?.compact_record_count!==compact.length)throw new Error('The combined C++ sidecar compact-record count does not match the frozen payload.');
   if(cppLatestView.baseline?.data_sha256!==snapshot.source_data_sha256)throw new Error('The combined C++ sidecar source data hash does not match the frozen payload.');
@@ -398,11 +398,11 @@ function applyCppLatestView() {
     if(['java','python'].includes(decoded.comparison_profile)||decoded.comparison_profile!==item.source_comparison_profile||decoded.runtime!==item.source_runtime||decoded.family!==item.source_family)throw new Error(`Combined C++ provenance mismatch at compact row ${index}.`);
     if(typeof item.canonical_family!=='string'||!item.canonical_family||typeof item.source_host!=='string'||!item.source_host)throw new Error(`Combined C++ identity metadata is incomplete at compact row ${index}.`);
     const decodedTimingAdmitted=/^timing_admitted_/i.test(String(decoded.timing_profile_status??''));
-    if(Boolean(item.timing_admitted)!==decodedTimingAdmitted||item.pair_status!=='numeric')throw new Error(`Combined C++ admission metadata mismatch at compact row ${index}.`);
+    if(Boolean(item.timing_admitted)!==decodedTimingAdmitted||!['numeric','partial_numeric'].includes(item.pair_status))throw new Error(`Combined C++ admission metadata mismatch at compact row ${index}.`);
     cpp.push({...decoded,comparison_profile:'cpp',family:item.canonical_family,source_family:item.source_family,source_comparison_profile:item.source_comparison_profile,source_runtime:item.source_runtime,source_execution_host:item.source_host,selection_authority:item.authority,pair_status:item.pair_status});
   }
   const ledger=cppLatestView.cpp?.pair_ledger;if(!Array.isArray(ledger))throw new Error('The combined C++ pair ledger is missing.');
-  for(const decision of ledger)if(decision.status!=='numeric'&&Array.isArray(decision.selected_raw_indices)&&decision.selected_raw_indices.length)throw new Error('A terminal N/A or unsupported decision attempts to fall back to an older numeric row.');
+  for(const decision of ledger)if(!['numeric','partial_numeric'].includes(decision.status)&&Array.isArray(decision.selected_raw_indices)&&decision.selected_raw_indices.length)throw new Error('A terminal N/A or unsupported decision attempts to fall back to an older numeric row.');
   const expectedTiming=new Set(cppLatestView.cpp?.timing_subset?.selected_raw_indices||[]),actualTiming=new Set(selected.filter(item=>item.timing_admitted).map(item=>item.raw_compact_index));
   if(expectedTiming.size!==actualTiming.size||[...expectedTiming].some(index=>!actualTiming.has(index)))throw new Error('The combined C++ admitted-timing index does not match selected-row metadata.');
   const imported=compact.map(decodeCompactRecord).filter(row=>['java','python'].includes(row.comparison_profile)).map(row=>{
@@ -463,7 +463,7 @@ void loadOperatorEffect();
 void loadDatasetCatalog();
 async function sha256Hex(buffer){const digest=await crypto.subtle.digest('SHA-256',buffer);return [...new Uint8Array(digest)].map(byte=>byte.toString(16).padStart(2,'0')).join('');}
 try {
-  const [snapshotResponse,sidecarResponse]=await Promise.all([fetch('./ui-data.json?v=20261013-cpp-latest-v1',{cache:'no-cache'}),fetch('./cpp-latest-view.json?v=20261013-cpp-latest-v1',{cache:'no-cache'})]);
+  const [snapshotResponse,sidecarResponse]=await Promise.all([fetch('./ui-data.json?v=20261015-float-scaling9-v1',{cache:'no-cache'}),fetch('./cpp-latest-view.json?v=20261015-float-scaling9-v1',{cache:'no-cache'})]);
   if(!snapshotResponse.ok)throw new Error(`Snapshot request returned ${snapshotResponse.status}`);if(!sidecarResponse.ok)throw new Error(`Combined C++ sidecar request returned ${sidecarResponse.status}`);
   const [snapshotBuffer,sidecarBuffer]=await Promise.all([snapshotResponse.arrayBuffer(),sidecarResponse.arrayBuffer()]);
   const sidecarSha=await sha256Hex(sidecarBuffer);if(sidecarSha!==CPP_LATEST_VIEW_SHA256)throw new Error('The combined C++ sidecar does not match the independently reviewed release selection.');

build_float_scaling9_site.py

@@ -0,0 +1,758 @@
+#!/usr/bin/env python3
+"""Build the 135-dataset merged-C++ website candidate for float-scaling9.
+
+The new experiment measures float columns only.  This importer keeps the
+currently selected integer rows, adds the verified float rows, and constructs
+dataset byte totals over the exact supported numeric set.  When a codec does
+not support some valid float blocks, that result remains explicitly partial.
+It never combines server-166 and server-192 timing: mixed dataset rows have
+unavailable timing by construction.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import gzip
+import hashlib
+import importlib.util
+import json
+import math
+import shutil
+import statistics
+import subprocess
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any, Iterable
+
+
+METHODS = ("2DIFF", "BOS", "DBP", "FastPFor", "LECO", "REGER", "RLBE", "SVB", "Simple8b")
+METHOD_SET = set(METHODS)
+BASE_CONFIG = {
+    "2DIFF": "compose_int64_default",
+    "BOS": "adapter_compose_int64",
+    "DBP": "compose_int64_default",
+    "FastPFor": "FastPFor8_prefix_then_variablebyte_tail",
+    "LECO": "regression_zigzag_bitpack",
+    "REGER": "reorder_delta_zigzag_for_bitpack_residual_core",
+    "RLBE": "rlbe_compose_int64",
+    "SVB": "compose_int64_default",
+    "Simple8b": "bitpack_int64_default",
+}
+SCALING_CONFIG = "typed_shortest_decimal_int64_exceptions_v1"
+PROFILE = "cpp-native192-float-scaling9-20261014-v2"
+RUNTIME = "cpp-native192-float-scaling9-0558378c"
+COMPOSITE_RUNTIME = "cpp-native166-192-float-scaling9-byte-composite-v1"
+BINARY_SHA256 = "0558378c92fe855f666da67d4f712043df084838619f35af9e2ae40dc183c704"
+BASELINE_REVISION = "86c9d336ea4b292b4b2fae7040d273fef9c58ca3"
+VERSION = "20261015-float-scaling9-v1"
+SIDECAR_STATUS = "built_from_frozen_published_baseline_and_accepted_float_scaling9"
+PUBLIC_OVERLAY = "float-scaling9-dataset-overlays.jsonl.gz"
+PUBLIC_ACCEPTANCE = "FLOAT_SCALING9_SITE_ACCEPTANCE.json"
+PUBLIC_INTEGRATION = "FLOAT_SCALING9_SITE_INTEGRATION.json"
+EXPECTED_BASELINE = {
+    "data.json": "b7b542c5731786d0486e89de889f024c7e6f69eacb68a7df67bc00179b07af4c",
+    "ui-data.json": "ef5aa05289f609f2f62ceed009ee17247c8b4767bba8f4aa8cd522ce83d3521d",
+    "cpp-latest-view.json": "5d2a8bb4fb5c38fbc4fa130a08b7608c7568f3959ef9dd2706f245862907f90f",
+    "final-dataset-scope.json": "b56f9bd610e0bf63ab50d719ce70cf92ddc1b79e6b30fd2c6e2f707944b2ba72",
+    "final-input-status.json": "07aef0e1503fbc1cc3bed267ccb3d4e1f613a12c25fbf6166be97b5234cb0520",
+    "app.js": "7eef44a621e941da3bae62d5b525354d5a3d9e202aa850fef575a19d58616313",
+    "index.html": "5747201663183aef9f665130c7ccf023982df676b9e3c7822d566cf6ed177ebe",
+    "manifest.json": "c226349a05d564cfc2498397c30e51308cc8dcfb65df94e9e7927527af955b88",
+}
+EXPECTED_COMPACT = {
+    "FLOAT_COLUMN_RESULTS.jsonl": "43884b68676c265c99e7ea73d5d026aba939c04f50a1df4d29d570d285577ab2",
+    "FLOAT_DATASET_METHOD_OVERLAY.jsonl": "77f016e4fe87f81a178749ba315627089420b23dd27dd26aa1ac50f09415eda5",
+    "SOURCE_BINDINGS.json": "b1e392e009b379e85b20c5d701954482b16873a2de536bb506f86da7dc61d59f",
+    "SUMMARY.json": "d9e97cff8707ab20cf9f28e33b8dbf9dbfeee9edf224edfc66b89662587a031f",
+    "DELIVERY_RECEIPT.json": "57ec6d83bd13e8e1312ba77266119a401e2fbfb37ede28170e753557187411ef",
+    "START.json": "d6b85101ef0960d56cf9ecd202f63ec8117630589adb8818160530583dfebe2d",
+    "CAMPAIGN_TERMINAL.json": "e0aa76d39ffb9d132b60f5075ac6f92df8c85a03c4d437d6097a9bd09e2a476f",
+}
+
+
+def require(value: Any, message: str) -> None:
+    if not value:
+        raise ValueError(message)
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(8 << 20), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def canonical(value: Any) -> bytes:
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()
+
+
+def canonical_sha(value: Any) -> str:
+    return hashlib.sha256(canonical(value)).hexdigest()
+
+
+def read_json(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text())
+    require(isinstance(value, dict), f"expected JSON object: {path}")
+    return value
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows = [json.loads(line) for line in path.read_text().splitlines() if line.strip()]
+    require(all(isinstance(row, dict) for row in rows), f"non-object JSONL row: {path}")
+    return rows
+
+
+def write_json(path: Path, value: Any) -> None:
+    path.write_text(json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n")
+
+
+def write_gzip_jsonl(path: Path, rows: Iterable[dict[str, Any]]) -> None:
+    with path.open("xb") as raw:
+        with gzip.GzipFile(filename="", mode="wb", fileobj=raw, mtime=0) as zipped:
+            for row in rows:
+                zipped.write(canonical(row) + b"\n")
+
+
+def median3(values: list[Any]) -> float:
+    require(len(values) == 3 and all(type(value) is int and value >= 0 for value in values), "invalid W1/R3 timing samples")
+    return float(statistics.median(values))
+
+
+def exact_configuration(method: str) -> str:
+    return f"{SCALING_CONFIG};base={BASE_CONFIG[method]}"
+
+
+def load_augmentation(path: Path | None) -> dict[tuple[str, str, str], dict[str, Any]]:
+    if path is None:
+        return {}
+    rows = read_jsonl(path)
+    result: dict[tuple[str, str, str], dict[str, Any]] = {}
+    for row in rows:
+        key = str(row["dataset_id"]), str(row["method"]), str(row["column_key"])
+        require(key not in result, f"duplicate augmentation row: {key}")
+        result[key] = row
+    return result
+
+
+def validate_compact(compact: Path, augmentation_path: Path | None) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+    for name, expected in EXPECTED_COMPACT.items():
+        require((compact / name).is_file() and sha256(compact / name) == expected, f"compact input SHA mismatch: {name}")
+    summary = read_json(compact / "SUMMARY.json")
+    terminal = read_json(compact / "CAMPAIGN_TERMINAL.json")
+    start = read_json(compact / "START.json")
+    bindings = read_json(compact / "SOURCE_BINDINGS.json")
+    delivery = read_json(compact / "DELIVERY_RECEIPT.json")
+    require(summary.get("status") == "summarized_verified_receipts_not_independent_acceptance", "unexpected compact summary status")
+    require(terminal.get("status") == "completed_unreviewed", "producer terminal changed")
+    require(terminal.get("completed_verified_jobs") == 1206 and terminal.get("completed_verified_columns") == 27522, "producer terminal count mismatch")
+    require(terminal.get("failed_jobs") == 0 and terminal.get("failed_columns") == 0, "producer reports failures")
+    require(start.get("workers") == 6 and start.get("warmups") == 1 and start.get("repeats") == 3 and start.get("threads_per_scientific_cli") == 1 and start.get("cold_verifications") == 2, "scientific execution contract changed")
+    require(start.get("old_results_selected") is False and start.get("compound_frame") == "P172B861", "new attempt/result boundary changed")
+    require(bindings.get("runtime_cli_sha256") == BINARY_SHA256 and bindings.get("result_jsonl_sha_verified_before_use") is True, "runtime/result binding changed")
+    require(delivery.get("status") == "complete", "compact delivery incomplete")
+
+    augmentation = load_augmentation(augmentation_path)
+    columns = read_jsonl(compact / "FLOAT_COLUMN_RESULTS.jsonl")
+    overlays = read_jsonl(compact / "FLOAT_DATASET_METHOD_OVERLAY.jsonl")
+    require(len(columns) == 27522 and len(overlays) == 1206, "compact row counts differ")
+    require({row["method"] for row in overlays} == METHOD_SET, "method set differs")
+    require(len({row["dataset_id"] for row in overlays}) == 134, "float dataset count differs")
+    require(len({(row["dataset_id"], row["method"]) for row in overlays}) == 1206, "duplicate dataset-method overlay")
+
+    grouped: dict[tuple[str, str], list[dict[str, Any]]] = defaultdict(list)
+    for row in columns:
+        method = str(row["method"])
+        dataset = str(row["dataset_id"])
+        key = dataset, method, str(row["column_key"])
+        extra = augmentation.get(key, {})
+        configuration = row.get("exact_configuration") or extra.get("exact_configuration") or exact_configuration(method)
+        require(configuration == exact_configuration(method), f"configuration differs: {dataset}/{method}")
+        support_sha = row.get("numeric_support_set_sha256") or extra.get("numeric_support_set_sha256")
+        support_identity_status = "exact_numeric_block_support_sha256"
+        if support_sha is None and int(row["unsupported_rows"]) == 0:
+            # With no codec-dependent unsupported block, the frozen column
+            # manifest is the complete support identity.  All-missing N/A
+            # blocks are input-determined and identical across methods.
+            support_sha = canonical_sha({
+                "support": "complete_frozen_column_manifest_excluding_input_all_missing_blocks",
+                "column_key": row["column_key"],
+                "column_manifest_sha256": row["column_manifest_sha256"],
+                "numeric_rows": int(row["numeric_rows"]),
+                "not_applicable_rows": int(row["not_applicable_rows"]),
+            })
+            support_identity_status = "complete_frozen_column_manifest_support_sha256"
+        elif support_sha is None:
+            # The compact v1 feed does not expose the exact identities of
+            # codec-dependent unsupported blocks.  Bind the real result file
+            # conservatively, so this partial support can never be mistaken
+            # for another method's full/comparable support set.
+            support_sha = canonical_sha({
+                "support": "method_specific_partial_result_bound",
+                "column_key": row["column_key"],
+                "column_manifest_sha256": row["column_manifest_sha256"],
+                "result_jsonl_sha256": row["result_jsonl_sha256"],
+                "numeric_rows": int(row["numeric_rows"]),
+                "not_applicable_rows": int(row["not_applicable_rows"]),
+                "unsupported_rows": int(row["unsupported_rows"]),
+            })
+            support_identity_status = "conservative_method_specific_partial_result_sha256"
+        require(isinstance(support_sha, str) and len(support_sha) == 64, f"numeric support identity missing: {key}")
+        samples_c = [row[f"compression_ns_sample_{index}"] for index in range(3)]
+        samples_d = [row[f"decompression_ns_sample_{index}"] for index in range(3)]
+        require(math.isclose(float(row["compression_ns_median_of_aligned_sums"]), median3(samples_c), rel_tol=0, abs_tol=0), "column compression median mismatch")
+        require(math.isclose(float(row["decompression_ns_median_of_aligned_sums"]), median3(samples_d), rel_tol=0, abs_tol=0), "column decompression median mismatch")
+        points = int(row["measured_valid_value_count"])
+        require(points == int(row["scaled_value_count"]) + int(row["exception_value_count"]), f"measured valid value count mismatch: {key}")
+        original = int(row["original_numeric_bytes"])
+        compressed = int(row["scientific_compressed_bytes"])
+        if points:
+            require(original > 0 and compressed > 0 and math.isclose(float(row["compression_ratio"]), compressed / original, rel_tol=1e-12), "column byte/rate mismatch")
+        else:
+            require(original == 0 and row["support_state"] == "unsupported", "zero-point column is not explicit unsupported")
+        grouped[dataset, method].append({**row, "point_count": points, "numeric_support_set_sha256": support_sha, "support_identity_status": support_identity_status, "exact_configuration": configuration})
+
+    by_pair = {(row["dataset_id"], row["method"]): row for row in overlays}
+    public: list[dict[str, Any]] = []
+    for pair, source_columns in sorted(grouped.items()):
+        require(pair in by_pair, f"column pair absent from overlay: {pair}")
+        overlay = by_pair[pair]
+        require(len(source_columns) == int(overlay["column_count"]), f"column count mismatch: {pair}")
+        numeric = [row for row in source_columns if row["point_count"] > 0]
+        require(numeric, f"no numeric support: {pair}")
+        original = sum(int(row["original_numeric_bytes"]) for row in numeric)
+        compressed = sum(int(row["scientific_compressed_bytes"]) for row in numeric)
+        points = sum(int(row["point_count"]) for row in numeric)
+        require(original == int(overlay["original_numeric_bytes"]) and compressed == int(overlay["scientific_compressed_bytes"]), f"dataset overlay byte mismatch: {pair}")
+        require(points == int(overlay["measured_valid_value_count"]) == int(overlay["scaled_value_count"]) + int(overlay["exception_value_count"]), f"dataset overlay point mismatch: {pair}")
+        support_rows = sorted((str(row["column_key"]), row["numeric_support_set_sha256"], row["support_identity_status"]) for row in numeric)
+        support_summary_sha = canonical_sha(support_rows)
+        support_sha = overlay.get("numeric_support_set_sha256")
+        require(isinstance(support_sha, str) and len(support_sha) == 64, f"dataset exact numeric support identity missing: {pair}")
+        require(overlay.get("exact_configuration") == exact_configuration(pair[1]), f"dataset exact configuration differs: {pair}")
+        compression_per_point = statistics.mean(float(row["compression_ns_median_of_aligned_sums"]) / row["point_count"] for row in numeric)
+        decompression_per_point = statistics.mean(float(row["decompression_ns_median_of_aligned_sums"]) / row["point_count"] for row in numeric)
+        public.append({
+            "schema": "compressionbenchmark-float-scaling9-dataset-overlay-v1",
+            "dataset": pair[0], "family": pair[1], "scope": "float",
+            "algorithm_variant": exact_configuration(pair[1]),
+            "runtime": RUNTIME, "comparison_profile": PROFILE,
+            "execution_host": "192.168.99.20", "binary_sha256": BINARY_SHA256,
+            "original_size_bytes": original, "compressed_size_bytes": compressed,
+            "compression_rate": compressed / original, "point_count": points,
+            "compression_time_ns_per_point": compression_per_point,
+            "decompression_time_ns_per_point": decompression_per_point,
+            "timing_column_count": len(numeric), "timing_aggregation": "column_mean",
+            "eligible_column_set_sha256": support_sha,
+            "eligible_column_set_status": "exact_sorted_numeric_block_id_sha256",
+            "column_support_summary_sha256": support_summary_sha,
+            "eligible_dtype_scope": "float",
+            "support_state": overlay["support_state"],
+            "numeric_column_count": len(numeric),
+            "unsupported_column_count": sum(row["point_count"] == 0 for row in source_columns),
+            "block_status_counts": {
+                "ok": int(overlay["numeric_rows"]),
+                "N/A": int(overlay["not_applicable_rows"]),
+                "unsupported": int(overlay["unsupported_rows"]),
+            },
+            "scaled_value_count": int(overlay["scaled_value_count"]),
+            "exception_value_count": int(overlay["exception_value_count"]),
+            "missing_count": int(overlay["missing_count"]),
+            "measured_logical_value_count": int(overlay["measured_logical_value_count"]),
+            "unsupported_valid_value_count": int(overlay["unsupported_valid_value_count"]),
+            "column_terminal_set_sha256": overlay["column_terminal_set_sha256"],
+            "job_terminal_sha256": overlay["job_terminal_sha256"],
+            "scientific_profile": overlay["scientific_profile"],
+        })
+    require(len(public) == 1206 and len({(row["dataset"], row["family"]) for row in public}) == 1206, "public overlay coverage differs")
+    partial_rows = [row for row in public if row["unsupported_valid_value_count"] > 0]
+    support_by_method = {}
+    for method in METHODS:
+        affected = sorted(row["dataset"] for row in partial_rows if row["family"] == method)
+        unsupported_values = sum(row["unsupported_valid_value_count"] for row in partial_rows if row["family"] == method)
+        support_by_method[method] = {
+            "measurement_row_dataset_count_with_NYC": 135,
+            "full_numeric_workload_dataset_count_with_NYC": 135 - len(affected),
+            "partial_numeric_dataset_count": len(affected),
+            "partial_numeric_datasets": affected,
+            "unsupported_valid_value_count": unsupported_values,
+        }
+    audit = {
+        "source_file_sha256": {name: EXPECTED_COMPACT[name] for name in EXPECTED_COMPACT},
+        "augmentation": None if augmentation_path is None else {"file": augmentation_path.name, "sha256": sha256(augmentation_path), "rows": len(augmentation)},
+        "dataset_count": 134, "method_count": 9, "dataset_method_count": 1206,
+        "column_method_count": 27522, "failed_jobs": 0, "failed_columns": 0,
+        "runtime_binary_sha256": BINARY_SHA256,
+        "timing_contract": "W1/R3/T1/cold2; per-dataset website ns/point is the arithmetic mean of per-column median(aligned block sums)/valid numeric point count; compression includes frozen whole-column precision derivation",
+        "cross_host_timing": "forbidden",
+        "support_semantics": {
+            "measurement_row_pair_count": 1206,
+            "full_numeric_workload_pair_count": 1206 - len(partial_rows),
+            "partial_numeric_pair_count": len(partial_rows),
+            "unsupported_valid_value_count": sum(row["unsupported_valid_value_count"] for row in partial_rows),
+            "by_method": support_by_method,
+            "coverage_note": "135/135 is measurement-row dataset coverage after retaining pure-integer NYC; it is not full numeric workload coverage for partial_numeric pairs.",
+        },
+    }
+    return public, audit
+
+
+def compact_rows(ui: dict[str, Any]) -> list[dict[str, Any]]:
+    tables = ui["record_tables"]
+    decoded = []
+    for index, row in enumerate(ui["compact_records"]):
+        decoded.append({
+            "raw_compact_index": index,
+            "dataset": tables["datasets"][row[0]],
+            "scope": tables["scopes"][row[1]],
+            "runtime": tables["runtimes"][row[2]],
+            "comparison_profile": tables["comparison_profiles"][row[3]],
+            "family": tables["families"][row[4]],
+            "algorithm_variant": tables["configurations"][row[5]],
+            "eligible_column_set_sha256": tables["support_sets"][row[13]],
+            "measurement_status": tables["measurement_statuses"][row[14]],
+            "timing_profile_status": tables["timing_statuses"][row[15]],
+        })
+    return decoded
+
+
+def site_rows(public_rows: list[dict[str, Any]], old_integer: dict[tuple[str, str], dict[str, Any]], acceptance_sha: str) -> tuple[list[dict[str, Any]], dict[str, int]]:
+    additions: list[dict[str, Any]] = []
+    mixed = pure = 0
+    for source in sorted(public_rows, key=lambda row: (row["dataset"], row["family"])):
+        partial_numeric = int(source["unsupported_valid_value_count"]) > 0
+        float_measurement_status = (
+            "float_scaling9_partial_numeric_support_unsupported_valid_values_excluded_rate_bytes_dual_cold"
+            if partial_numeric else
+            "float_scaling9_full_numeric_support_verified_receipts_exact_support_rate_bytes_dual_cold"
+        )
+        base = {
+            "schema": "compressionbenchmark-float-scaling9-site-row-v1",
+            "dataset": source["dataset"], "runtime": RUNTIME,
+            "comparison_profile": PROFILE, "family": source["family"],
+            "method": source["algorithm_variant"],
+            "algorithm_variant": f"{source['algorithm_variant']} [{BINARY_SHA256[:8]}]",
+            "is_best_rate_in_family": True,
+            "original_size_bytes": source["original_size_bytes"],
+            "compressed_size_bytes": source["compressed_size_bytes"],
+            "point_count": source["point_count"],
+            "compression_rate": source["compression_rate"],
+            "compression_time_ns_per_point": source["compression_time_ns_per_point"],
+            "decompression_time_ns_per_point": source["decompression_time_ns_per_point"],
+            "compression_time_ns": source["compression_time_ns_per_point"] * source["point_count"],
+            "decompression_time_ns": source["decompression_time_ns_per_point"] * source["point_count"],
+            "timing_column_count": source["timing_column_count"],
+            "timing_aggregation": "column_mean",
+            "eligible_dtype_scope": "float",
+            "eligible_column_set_sha256": source["eligible_column_set_sha256"],
+            "eligible_column_set_status": source["eligible_column_set_status"],
+            "measurement_status": float_measurement_status,
+            "timing_profile_status": "timing_admitted_float_scaling9_server192_w1_r3_t1_column_mean_acceptance_bound",
+            "execution_host": "192.168.99.20", "binary_sha256": BINARY_SHA256,
+            "profile_version": source["scientific_profile"],
+            "input_version": "final135-frozen-inputs-20261014-v1",
+            "acceptance_sha256": acceptance_sha,
+            "job_terminal_sha256": source["job_terminal_sha256"],
+            "column_terminal_set_sha256": source["column_terminal_set_sha256"],
+            "support_state": source["support_state"],
+        }
+        float_row = {**base, "scope": "float"}
+        additions.append(float_row)
+        integer = old_integer.get((source["dataset"], source["family"]))
+        if integer is None:
+            pure += 1
+            additions.append({**base, "scope": "overall", "eligible_dtype_scope": "overall"})
+            continue
+        mixed += 1
+        original = int(integer["original_size_bytes"]) + int(source["original_size_bytes"])
+        compressed = int(integer["compressed_size_bytes"]) + int(source["compressed_size_bytes"])
+        points = float(integer["point_count"]) + float(source["point_count"])
+        composite_identity = {
+            "integer": {
+                "comparison_profile": integer["comparison_profile"],
+                "runtime": integer["runtime"],
+                "algorithm_variant": integer["algorithm_variant"],
+                "binary_sha256": integer.get("binary_sha256") or "unbound",
+                "eligible_column_set_sha256": integer["eligible_column_set_sha256"],
+            },
+            "float": {
+                "comparison_profile": PROFILE, "runtime": RUNTIME,
+                "algorithm_variant": source["algorithm_variant"],
+                "binary_sha256": BINARY_SHA256,
+                "eligible_column_set_sha256": source["eligible_column_set_sha256"],
+            },
+        }
+        composite_sha = canonical_sha(composite_identity)
+        additions.append({
+            **base,
+            "scope": "overall", "runtime": COMPOSITE_RUNTIME,
+            "method": f"integer={integer['algorithm_variant']};float={source['algorithm_variant']}",
+            "algorithm_variant": f"integer={integer['algorithm_variant']};float={source['algorithm_variant']} [composite {composite_sha[:8]}]",
+            "original_size_bytes": original, "compressed_size_bytes": compressed,
+            "point_count": points, "compression_rate": compressed / original,
+            "compression_time_ns": None, "decompression_time_ns": None,
+            "compression_time_ns_per_point": None, "decompression_time_ns_per_point": None,
+            "timing_column_count": 0, "timing_aggregation": "unavailable",
+            "eligible_dtype_scope": "overall",
+            "eligible_column_set_sha256": canonical_sha(composite_identity),
+            "eligible_column_set_status": "exact_scope_component_support_and_source_identity_sha256",
+            "measurement_status": (
+                "whole_dataset_partial_numeric_rate_bytes_composed_from_integer166_and_supported_float192_subset"
+                if partial_numeric else
+                "whole_dataset_full_numeric_rate_bytes_composed_from_accepted_integer166_and_float192_components"
+            ),
+            "timing_profile_status": "timing_unavailable_cross_host_scope_composition_forbidden",
+            "execution_host": "166.111.68.166 + 192.168.99.20",
+            "binary_sha256": composite_sha,
+            "component_identity": composite_identity,
+        })
+    require(mixed == 63 * 9 and pure == 71 * 9, f"unexpected mixed/pure pair counts: {mixed}/{pure}")
+    require(len(additions) == 2412, "site row addition count differs")
+    return additions, {"mixed_dataset_method_pairs": mixed, "pure_float_dataset_method_pairs": pure, "new_dataset_result_rows": len(additions)}
+
+
+def build_sidecar(old_sidecar: dict[str, Any], old_ui: dict[str, Any], new_ui: dict[str, Any], additions: list[dict[str, Any]], data_sha: str, ui_sha: str, acceptance_path: Path, overlay_path: Path) -> dict[str, Any]:
+    old_decoded = compact_rows(old_ui)
+    new_decoded = compact_rows(new_ui)
+    old_count = len(old_decoded)
+    override_pairs = {(row["dataset"], row["family"]) for row in additions}
+    # additions has two rows per pair; the set remains exact 134 x 9.
+    require(len(override_pairs) == 1206, "override pair set differs")
+    partial_pairs = {
+        (row["dataset"], row["family"])
+        for row in additions
+        if "partial_numeric" in row["measurement_status"]
+    }
+    require(len(partial_pairs) == 113, "partial numeric pair count differs")
+
+    retained: list[dict[str, Any]] = []
+    retained_integer: dict[tuple[str, str], dict[str, Any]] = {}
+    for item in old_sidecar["cpp"]["selected_rows"]:
+        decoded = old_decoded[item["raw_compact_index"]]
+        pair = decoded["dataset"], item["canonical_family"]
+        if pair not in override_pairs:
+            retained.append(item)
+        elif decoded["scope"] == "integer":
+            require(pair not in retained_integer, f"multiple prior integer rows: {pair}")
+            retained_integer[pair] = {
+                **item,
+                "authority": "float_scaling9_scope_composite_latest",
+                "pair_status": "partial_numeric" if pair in partial_pairs else "numeric",
+            }
+            retained.append(retained_integer[pair])
+
+    for index in range(old_count, len(new_decoded)):
+        decoded = new_decoded[index]
+        require((decoded["dataset"], decoded["family"]) in override_pairs, "unexpected appended compact row")
+        timing_admitted = decoded["timing_profile_status"].startswith("timing_admitted_")
+        source_host = "192.168.99.20" if decoded["runtime"] == RUNTIME else "166.111.68.166 + 192.168.99.20"
+        retained.append({
+            "raw_compact_index": index,
+            "canonical_family": decoded["family"],
+            "source_family": decoded["family"],
+            "source_comparison_profile": decoded["comparison_profile"],
+            "source_runtime": decoded["runtime"],
+            "source_host": source_host,
+            "authority": "float_scaling9_scope_composite_latest",
+            "pair_status": "partial_numeric" if (decoded["dataset"], decoded["family"]) in partial_pairs else "numeric",
+            "timing_admitted": timing_admitted,
+            "measurement_status": decoded["measurement_status"],
+            "timing_profile_status": decoded["timing_profile_status"],
+        })
+
+    ledger = [item for item in old_sidecar["cpp"]["pair_ledger"] if (item["dataset"], item["canonical_family"]) not in override_pairs]
+    all_scopes = set(new_ui["record_tables"]["scopes"])
+    by_pair: dict[tuple[str, str], list[dict[str, Any]]] = defaultdict(list)
+    for item in retained:
+        row = new_decoded[item["raw_compact_index"]]
+        by_pair[row["dataset"], item["canonical_family"]].append({"selection": item, "row": row})
+    for pair in sorted(override_pairs):
+        selected = by_pair[pair]
+        scopes = sorted({item["row"]["scope"] for item in selected})
+        require("float" in scopes and "overall" in scopes and (scopes == ["float", "overall"] or "integer" in scopes), f"composite scopes differ: {pair}")
+        ledger.append({
+            "dataset": pair[0], "canonical_family": pair[1],
+            "decision": "select_latest_scope_composite",
+            "status": "partial_numeric" if pair in partial_pairs else "numeric",
+            "source_comparison_profile": PROFILE,
+            "source_comparison_profiles": sorted({item["selection"]["source_comparison_profile"] for item in selected}),
+            "source_hosts": sorted({item["selection"]["source_host"] for item in selected}),
+            "selected_raw_indices": sorted(item["selection"]["raw_compact_index"] for item in selected),
+            "selected_scopes": scopes,
+            "missing_scopes_tombstoned": sorted(all_scopes - set(scopes)),
+            "recency_rank": 50,
+            "authority": "float_scaling9_scope_composite_latest",
+            "reason": (
+                "The newest float-scaling9 measurement covers an exact supported numeric subset; valid unsupported float values are excluded and bound by the support SHA. Retained integer bytes plus supported float-subset bytes are not a full-workload total, and cross-host timing is unavailable."
+                if pair in partial_pairs else
+                "Accepted float-scaling9 overlay is newest for float/overall; an existing accepted integer row is retained only when the dataset has integer columns. Mixed overall bytes are composed and cross-host timing is unavailable."
+            ),
+            "acceptance_sha256": sha256(acceptance_path),
+        })
+
+    retained.sort(key=lambda item: item["raw_compact_index"])
+    ledger.sort(key=lambda item: (item["dataset"], item["canonical_family"]))
+    timing_indices = [item["raw_compact_index"] for item in retained if item["timing_admitted"]]
+    active = set(old_sidecar["cpp"]["active_native85_families"])
+    active_ledger = [item for item in ledger if item["canonical_family"] in active]
+    pair_status = Counter(item["status"] for item in active_ledger)
+    scope_dataset_counts = {scope: len({new_decoded[item["raw_compact_index"]]["dataset"] for item in retained if new_decoded[item["raw_compact_index"]]["scope"] == scope}) for scope in all_scopes}
+    scope_pair_counts = {scope: len({(new_decoded[item["raw_compact_index"]]["dataset"], item["canonical_family"]) for item in retained if new_decoded[item["raw_compact_index"]]["scope"] == scope}) for scope in all_scopes}
+
+    sidecar = json.loads(json.dumps(old_sidecar))
+    sidecar["status"] = SIDECAR_STATUS
+    sidecar["baseline"] = {
+        "revision": BASELINE_REVISION,
+        "ui_data_path": "ui-data.json", "ui_data_sha256": ui_sha,
+        "data_path": "data.json", "data_sha256": data_sha,
+        "compact_record_count": len(new_decoded),
+        "parent_published_payload": {"data_sha256": EXPECTED_BASELINE["data.json"], "ui_data_sha256": EXPECTED_BASELINE["ui-data.json"]},
+    }
+    sidecar["identity_contract"]["atomicity"] = "One latest authority wins per dataset and canonical family. The float-scaling9 authority may be a scope composite: new float plus retained integer and an explicitly byte-composed overall row. Every selected row keeps its own source profile/runtime/host."
+    sidecar["precedence"].append({"rank": 50, "authority": "float_scaling9_scope_composite_latest", "scope": "134 float-bearing datasets x nine integer-codec families; exact float support plus retained integer component"})
+    sidecar["receipts"][PUBLIC_ACCEPTANCE] = {"path": PUBLIC_ACCEPTANCE, "sha256": sha256(acceptance_path), "schema": read_json(acceptance_path)["schema"], "status": read_json(acceptance_path)["status"]}
+    sidecar["receipts"][PUBLIC_OVERLAY] = {"path": PUBLIC_OVERLAY, "sha256": sha256(overlay_path)}
+    sidecar["cpp"]["selected_rows"] = retained
+    sidecar["cpp"]["pair_ledger"] = ledger
+    sidecar["cpp"]["counts"] = {
+        "active_native85_pair_conclusions": len(active_ledger),
+        "active_native85_pair_status": dict(sorted(pair_status.items())),
+        "active_native85_numeric_pairs": pair_status["numeric"],
+        "active_native85_partial_numeric_pairs": pair_status["partial_numeric"],
+        "active_native85_measured_numeric_pairs": pair_status["numeric"] + pair_status["partial_numeric"],
+        "active_native85_terminal_tombstone_pairs": pair_status["not_applicable"] + pair_status["unsupported"],
+        "legacy_extra_pair_count": sum(item["authority"] == "legacy_extra_family_preserved_all_configurations" for item in ledger),
+        "selected_compact_row_count": len(retained),
+        "timing_admitted_selected_row_count": len(timing_indices),
+        "scope_numeric_dataset_counts": dict(sorted(scope_dataset_counts.items())),
+        "scope_numeric_pair_counts": dict(sorted(scope_pair_counts.items())),
+        "float_scaling9_dataset_count": 134,
+        "float_scaling9_pair_count": 1206,
+        "float_scaling9_measurement_row_coverage_pairs_with_retained_NYC": 1215,
+        "float_scaling9_full_numeric_workload_pairs_with_retained_NYC": 1102,
+        "float_scaling9_partial_numeric_pairs": 113,
+    }
+    sidecar["cpp"]["timing_subset"] = {
+        "contract": "Only row-local admitted timing is selectable. Server-192 float timing remains its own source profile; mixed server-166/server-192 overall rows have null timing and are never pooled.",
+        "selected_raw_indices": timing_indices,
+        "selected_row_count": len(timing_indices),
+        "source_profile_counts": dict(sorted(Counter(item["source_comparison_profile"] for item in retained if item["timing_admitted"]).items())),
+    }
+    sidecar["warnings"] = [warning for warning in sidecar["warnings"] if "FreshRetailNet-50K corrected" not in warning]
+    sidecar["warnings"].append("Float-scaling9 timing was measured on server 192 and is never merged with server-166 integer timing; mixed overall rows expose bytes/rate only.")
+    sidecar["warnings"].append("For 113 dataset-method pairs, valid float values were unsupported. Their rows expose exact supported-subset rates and support SHA identities and are marked partial_numeric; 135/135 denotes measurement-row coverage, not full-workload support.")
+    return sidecar
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--baseline", type=Path, required=True)
+    parser.add_argument("--compact", type=Path, required=True)
+    parser.add_argument("--augmentation", type=Path)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    baseline, compact, output = args.baseline.resolve(), args.compact.resolve(), args.output.resolve()
+    require(not output.exists(), "candidate exists; preserve it and choose a new output")
+    for name, expected in EXPECTED_BASELINE.items():
+        require((baseline / name).is_file() and sha256(baseline / name) == expected, f"published baseline SHA mismatch: {name}")
+    public_rows, compact_audit = validate_compact(compact, None if args.augmentation is None else args.augmentation.resolve())
+
+    scope = read_json(baseline / "final-dataset-scope.json")
+    input_status = read_json(baseline / "final-input-status.json")
+    measured = set(scope["datasets"]) - {item["dataset_id"] for item in input_status["pending_datasets"]}
+    float_datasets = {row["dataset"] for row in public_rows}
+    require(len(measured) == 135 and float_datasets | {"NYC_Yellow_Taxi_Trip"} == measured and "NYC_Yellow_Taxi_Trip" not in float_datasets, "float campaign is not exact current measured scope minus pure-integer NYC")
+
+    old_data = read_json(baseline / "data.json")
+    old_ui = read_json(baseline / "ui-data.json")
+    old_sidecar = read_json(baseline / "cpp-latest-view.json")
+    decoded = compact_rows(old_ui)
+    old_integer: dict[tuple[str, str], dict[str, Any]] = {}
+    for item in old_sidecar["cpp"]["selected_rows"]:
+        row = decoded[item["raw_compact_index"]]
+        pair = row["dataset"], item["canonical_family"]
+        if row["dataset"] in measured and item["canonical_family"] in METHOD_SET and row["scope"] == "integer":
+            require(pair not in old_integer, f"multiple selected integer records: {pair}")
+            full = old_data["dataset_results"][item["raw_compact_index"]]
+            require(full["dataset"] == row["dataset"] and full["scope"] == "integer", "full/compact baseline row mismatch")
+            old_integer[pair] = full
+    require(len(old_integer) == 64 * 9 and len({dataset for dataset, _ in old_integer}) == 64, "old integer component coverage differs")
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(baseline, output)
+    public_overlay_path = output / PUBLIC_OVERLAY
+    write_gzip_jsonl(public_overlay_path, public_rows)
+    acceptance = {
+        "schema": "compressionbenchmark-float-scaling9-site-acceptance-v1",
+        "status": "accepted_for_rate_and_own_profile_timing",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "producer_terminal_status_preserved": "completed_unreviewed",
+        "validation": compact_audit,
+        "scope": {
+            "dataset_count_with_float": 134, "pure_integer_dataset_retained": "NYC_Yellow_Taxi_Trip",
+            "current_measured_dataset_count": 135, "method_count": 9,
+            "dataset_method_count": 1206, "column_method_count": 27522,
+            "method_ids": list(METHODS),
+        },
+        "public_overlay": {"file": PUBLIC_OVERLAY, "sha256": sha256(public_overlay_path), "rows": len(public_rows)},
+        "admission": {
+            "rate_bytes": "accepted exact P172B861 complete-frame bytes over the exact supported numeric subset; partial rows are never described as full-workload coverage",
+            "float_timing": "accepted only over the exact supported numeric subset within the server-192 profile as equal-column arithmetic mean of per-column ns/point",
+            "mixed_overall_timing": "unavailable; server-166 integer and server-192 float timing are never merged",
+            "unsupported_and_NA": "explicit states retained; no zero-valued results fabricated",
+        },
+    }
+    acceptance_path = output / PUBLIC_ACCEPTANCE
+    write_json(acceptance_path, acceptance)
+    acceptance_sha = sha256(acceptance_path)
+
+    additions, composition_counts = site_rows(public_rows, old_integer, acceptance_sha)
+    data = json.loads(json.dumps(old_data))
+    old_rows_sha = canonical_sha(data["dataset_results"])
+    old_count = len(data["dataset_results"])
+    require(not any(row.get("comparison_profile") == PROFILE for row in data["dataset_results"]), "float-scaling9 profile already integrated")
+    data["dataset_results"].extend(additions)
+    require(canonical_sha(data["dataset_results"][:old_count]) == old_rows_sha, "historical dataset result rows changed")
+
+    helper_path = output / "build_accepted_completion_v7.py"
+    spec = importlib.util.spec_from_file_location("float9_recompute", helper_path)
+    helper = importlib.util.module_from_spec(spec)
+    require(spec.loader is not None, "cannot load aggregate helper")
+    spec.loader.exec_module(helper)
+    helper.recompute(data)
+    helper.update_methods(data, additions)
+    data["benchmark"].setdefault("runtime_labels", {})[PROFILE] = "Native C++ · 192 · exact decimal scaling for nine integer codecs"
+    data["benchmark"].setdefault("runtime_hosts", {})[PROFILE] = "192 for float; 166+192 byte-only composition for mixed overall"
+    data["benchmark"]["implementation_runtimes"] = sorted({row["comparison_profile"] for row in data["dataset_results"]})
+    data["benchmark"]["exact_source_profiles"] = sorted({row["runtime"] for row in data["dataset_results"]})
+    run_summary = {
+        "schema": "float-scaling9-site-import-v1", "comparison_profile": PROFILE,
+        "execution_host": "192.168.99.20", "binary_sha256": BINARY_SHA256,
+        "dataset_count_with_float": 134, "method_count": 9, "pair_count": 1206,
+        **composition_counts,
+        "public_overlay": {"file": PUBLIC_OVERLAY, "sha256": sha256(public_overlay_path)},
+        "acceptance": {"file": PUBLIC_ACCEPTANCE, "sha256": acceptance_sha},
+        "timing_policy": "server192 float and pure-float overall only; mixed overall timing null; never enters server166-only figures",
+        "old_results_retained": True,
+    }
+    data["source"].setdefault("measurement_runs", []).append(run_summary)
+    coverage = data["coverage"]
+    coverage.update(
+        dataset_result_row_count=len(data["dataset_results"]),
+        configuration_aggregate_row_count=len(data["configuration_aggregates"]),
+        family_best_aggregate_row_count=len(data["family_best_aggregates"]),
+        method_family_count=len({row["family"] for row in data["dataset_results"]}),
+        method_configuration_count=len({row["algorithm_variant"] for row in data["dataset_results"]}),
+        runtime_configuration_count=len({(row["comparison_profile"], row["algorithm_variant"]) for row in data["dataset_results"]}),
+        runtime_count=len(data["benchmark"]["implementation_runtimes"]),
+        runtimes=data["benchmark"]["implementation_runtimes"],
+        timing_unavailable_dataset_result_count=sum(row.get("timing_aggregation") == "unavailable" for row in data["dataset_results"]),
+    )
+    coverage["float_scaling9"] = run_summary
+    write_json(output / "data.json", data)
+    subprocess.run([sys.executable, str(output / "build_ui_payload.py")], check=True, capture_output=True, text=True)
+    new_ui = read_json(output / "ui-data.json")
+    data_sha = sha256(output / "data.json")
+    ui_sha = sha256(output / "ui-data.json")
+    require(new_ui["source_data_sha256"] == data_sha and len(new_ui["compact_records"]) == len(data["dataset_results"]), "full/compact data closure differs")
+
+    sidecar = build_sidecar(old_sidecar, old_ui, new_ui, additions, data_sha, ui_sha, acceptance_path, public_overlay_path)
+    write_json(output / "cpp-latest-view.json", sidecar)
+    sidecar_sha = sha256(output / "cpp-latest-view.json")
+
+    app_path = output / "app.js"
+    app = app_path.read_text()
+    old_sha = EXPECTED_BASELINE["cpp-latest-view.json"]
+    require(app.count(old_sha) == 1 and app.count("20261013-cpp-latest-v1") == 2 and app.count("built_from_frozen_published_admitted_sources") == 1, "app cache/SHA/status anchors differ")
+    app = app.replace(old_sha, sidecar_sha)
+    app = app.replace("20261013-cpp-latest-v1", VERSION)
+    app = app.replace("built_from_frozen_published_admitted_sources", SIDECAR_STATUS)
+    require(app.count("item.pair_status!=='numeric'") == 1, "app pair-status guard anchor differs")
+    app = app.replace("item.pair_status!=='numeric'", "!['numeric','partial_numeric'].includes(item.pair_status)")
+    require(app.count("decision.status!=='numeric'&&Array.isArray(decision.selected_raw_indices)") == 1, "app ledger-status guard anchor differs")
+    app = app.replace("decision.status!=='numeric'&&Array.isArray(decision.selected_raw_indices)", "!['numeric','partial_numeric'].includes(decision.status)&&Array.isArray(decision.selected_raw_indices)")
+    old_support_note = "${countSupport(item=>item.status==='numeric'&&item.scopes.includes('overall'))} numeric Overall, ${countSupport(item=>item.status==='numeric'&&!item.scopes.includes('overall'))} numeric type-specific only, ${countSupport(item=>item.status==='not_applicable')} not applicable"
+    new_support_note = "${countSupport(item=>item.status==='numeric'&&item.scopes.includes('overall'))} full numeric Overall, ${countSupport(item=>item.status==='partial_numeric')} partial numeric (exact supported subset), ${countSupport(item=>item.status==='numeric'&&!item.scopes.includes('overall'))} full numeric type-specific only, ${countSupport(item=>item.status==='not_applicable')} not applicable"
+    require(app.count(old_support_note) == 1, "app support-note anchor differs")
+    app = app.replace(old_support_note, new_support_note)
+    app_path.write_text(app)
+    subprocess.run(["node", "--check", str(app_path)], check=True, capture_output=True, text=True)
+
+    index_path = output / "index.html"
+    index = index_path.read_text()
+    require(index.count('app.js?v=20261013-min128-input-gate-v1') == 1, "index app cache anchor differs")
+    index_path.write_text(index.replace('app.js?v=20261013-min128-input-gate-v1', f'app.js?v={VERSION}'))
+
+    manifest = read_json(output / "manifest.json")
+    manifest["data_sha256"] = data_sha
+    manifest["counts"] = coverage
+    manifest["measurement_runs"] = data["source"]["measurement_runs"]
+    manifest["float_scaling9"] = run_summary
+    manifest["cpp_latest_view"] = {
+        "file": "cpp-latest-view.json", "sha256": sidecar_sha,
+        "schema": sidecar["schema"], "status": sidecar["status"],
+    }
+    write_json(output / "manifest.json", manifest)
+
+    builder_copy = output / Path(__file__).name
+    shutil.copy2(Path(__file__), builder_copy)
+    changed = [
+        "data.json", "ui-data.json", "cpp-latest-view.json", "app.js", "index.html", "manifest.json",
+        PUBLIC_OVERLAY, PUBLIC_ACCEPTANCE, Path(__file__).name,
+    ]
+    integration = {
+        "schema": "compressionbenchmark-float-scaling9-site-integration-v1",
+        "status": "passed_not_published",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "parent_revision": BASELINE_REVISION,
+        "old_dataset_result_count": old_count,
+        "new_dataset_result_count": len(additions),
+        "final_dataset_result_count": len(data["dataset_results"]),
+        "historical_dataset_results_canonical_sha256": old_rows_sha,
+        "scope": {"measured_datasets": 135, "methods": 9, "method_dataset_pairs": 1215, **composition_counts},
+        "files": {name: {"bytes": (output / name).stat().st_size, "sha256": sha256(output / name)} for name in changed},
+        "publication_file_list": changed + [PUBLIC_INTEGRATION],
+        "semantic_checks": {
+            "old_rows_retained_byte_for_byte_in_canonical_order": True,
+            "new_float_rows": 1206, "new_overall_rows": 1206,
+            "mixed_overall_bytes_equal_integer_plus_float": 63 * 9,
+            "mixed_overall_timing_null": 63 * 9,
+            "pure_float_overall_timing_same_server192_profile": 71 * 9,
+            "NYC_pure_integer_rows_unchanged": 9,
+            "unsupported_or_NA_converted_to_zero": 0,
+            "measurement_row_coverage_pairs_with_retained_NYC": 1215,
+            "full_numeric_workload_pairs_with_retained_NYC": 1102,
+            "partial_numeric_pairs": 113,
+            "unsupported_valid_values_excluded_from_partial_rates": compact_audit["support_semantics"]["unsupported_valid_value_count"],
+            "index_app_cache_version": VERSION,
+            "app_javascript_syntax": "pass",
+        },
+        "page_checks_required_after_publication": [
+            "C++ overall shows 135/135 measurement-row coverage for the nine methods and separately labels partial_numeric supported-subset rows",
+            "Mixed-dataset overall rows show unavailable timing and retain both source hosts in details",
+            "Float-scope rows show server-192 provenance and exact scaling configuration",
+            "CSV keeps source profile, source host, binary/support SHA, measurement status, and timing status",
+        ],
+    }
+    integration_path = output / PUBLIC_INTEGRATION
+    write_json(integration_path, integration)
+    integration["files"][PUBLIC_INTEGRATION] = {"bytes": integration_path.stat().st_size, "sha256": sha256(integration_path)}
+    # Do not rewrite the integration after hashing itself; the external build
+    # result below binds the final integration file SHA without recursion.
+    build_result = {
+        "status": "passed_not_published", "output": str(output),
+        "data_sha256": data_sha, "ui_data_sha256": ui_sha,
+        "cpp_latest_view_sha256": sidecar_sha, "manifest_sha256": sha256(output / "manifest.json"),
+        "integration_sha256": sha256(integration_path),
+        "candidate_file_count": sum(path.is_file() for path in output.iterdir()),
+        "candidate_total_bytes": sum(path.stat().st_size for path in output.iterdir() if path.is_file()),
+        "publication_files": integration["publication_file_list"],
+        "counts": sidecar["cpp"]["counts"],
+    }
+    write_json(Path(__file__).with_name("BUILD_RESULT.json"), build_result)
+    print(json.dumps(build_result, ensure_ascii=False, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

cpp-latest-view.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5d2a8bb4fb5c38fbc4fa130a08b7608c7568f3959ef9dd2706f245862907f90f
-size 19973658
+oid sha256:564b8f7760a6336e93bd0d69601e74ada9819b361dc2464d768689af0d287cbd
+size 29094332

data.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b7b542c5731786d0486e89de889f024c7e6f69eacb68a7df67bc00179b07af4c
-size 134675991
+oid sha256:3c66633b2d58b126edfad8afe173caf1f53fbcdb6f7b205c3d51b42dfc75a241
+size 141118632

float-scaling9-dataset-overlays.jsonl.gz

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

index.html

@@ -7,7 +7,7 @@
   <meta name="color-scheme" content="light dark">
   <title>THULab | Time Series Compression Benchmark</title>
   <link rel="stylesheet" href="style.css?v=20261013-cpp-latest-v1">
-  <script src="app.js?v=20261013-min128-input-gate-v1" type="module"></script>
+  <script src="app.js?v=20261015-float-scaling9-v1" type="module"></script>
 </head>
 <body>
   <a class="skip-link" href="#content">Skip to results</a>

manifest.json

@@ -33,7 +33,7 @@
   },
   "counts": {
     "catalog_dataset_count": 164,
-    "configuration_aggregate_row_count": 5197,
+    "configuration_aggregate_row_count": 5782,
     "corrected_five425": {
       "active_method_count": 85,
       "all_na_pair_count": 0,
@@ -67,7 +67,7 @@
       "timing_admitted": false
     },
     "dataset_count": 164,
-    "dataset_result_row_count": 92559,
+    "dataset_result_row_count": 94971,
     "excluded_datasets": [
       "Arade",
       "app_flow",
@@ -79,9 +79,31 @@
       "tiktok_trending_hashtags_music",
       "youtube_trending_2019_2020"
     ],
-    "family_best_aggregate_row_count": 1916,
+    "family_best_aggregate_row_count": 1934,
+    "float_scaling9": {
+      "acceptance": {
+        "file": "FLOAT_SCALING9_SITE_ACCEPTANCE.json",
+        "sha256": "1a9cbcd4a2b38e770047734fa41f4b61c8f4919778fa80c53e11778a1e0db9e4"
+      },
+      "binary_sha256": "0558378c92fe855f666da67d4f712043df084838619f35af9e2ae40dc183c704",
+      "comparison_profile": "cpp-native192-float-scaling9-20261014-v2",
+      "dataset_count_with_float": 134,
+      "execution_host": "192.168.99.20",
+      "method_count": 9,
+      "mixed_dataset_method_pairs": 567,
+      "new_dataset_result_rows": 2412,
+      "old_results_retained": true,
+      "pair_count": 1206,
+      "public_overlay": {
+        "file": "float-scaling9-dataset-overlays.jsonl.gz",
+        "sha256": "027760f75a88dd8b91b658797855c3c5339ac74c7ef394105a37e4912f25afc7"
+      },
+      "pure_float_dataset_method_pairs": 639,
+      "schema": "float-scaling9-site-import-v1",
+      "timing_policy": "server192 float and pure-float overall only; mixed overall timing null; never enters server166-only figures"
+    },
     "measured_dataset_count": 164,
-    "method_configuration_count": 476,
+    "method_configuration_count": 932,
     "method_family_count": 104,
     "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,
@@ -380,8 +402,8 @@
     "native86_unresolved_problem_pair_count": 0,
     "native86_v9_recovered_pair_count": 154,
     "paper_leaderboard_row_count": 0,
-    "runtime_configuration_count": 1117,
-    "runtime_count": 12,
+    "runtime_configuration_count": 1573,
+    "runtime_count": 13,
     "runtimes": [
       "cpp",
       "cpp-native166-corrected-five-20261012-v1",
@@ -390,6 +412,7 @@
       "cpp-native166-row-support-v4-baseline86-fixed-profiles-20260919-v3",
       "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3",
       "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3",
+      "cpp-native192-float-scaling9-20261014-v2",
       "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2",
       "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-fixed-20261010-v1",
       "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3",
@@ -401,10 +424,16 @@
     "timing_column_mean_dataset_result_count": 25449,
     "timing_column_observation_count": 519087,
     "timing_dataset_aggregate_result_count": 0,
-    "timing_unavailable_dataset_result_count": 67110
+    "timing_unavailable_dataset_result_count": 67677
+  },
+  "cpp_latest_view": {
+    "file": "cpp-latest-view.json",
+    "schema": "compressionbenchmark-cpp-latest-view-v1",
+    "sha256": "564b8f7760a6336e93bd0d69601e74ada9819b361dc2464d768689af0d287cbd",
+    "status": "built_from_frozen_published_baseline_and_accepted_float_scaling9"
   },
   "data_file": "data.json",
-  "data_sha256": "b7b542c5731786d0486e89de889f024c7e6f69eacb68a7df67bc00179b07af4c",
+  "data_sha256": "3c66633b2d58b126edfad8afe173caf1f53fbcdb6f7b205c3d51b42dfc75a241",
   "dataset_catalog_sha256": "47869c8078e8c864810d4f961fa5879e120943bb3f371b39f0adc74f3de2ee2d",
   "excluded_content": [
     "raw datasets",
@@ -414,6 +443,28 @@
     "binaries and model artifacts",
     "external or vendored benchmark results"
   ],
+  "float_scaling9": {
+    "acceptance": {
+      "file": "FLOAT_SCALING9_SITE_ACCEPTANCE.json",
+      "sha256": "1a9cbcd4a2b38e770047734fa41f4b61c8f4919778fa80c53e11778a1e0db9e4"
+    },
+    "binary_sha256": "0558378c92fe855f666da67d4f712043df084838619f35af9e2ae40dc183c704",
+    "comparison_profile": "cpp-native192-float-scaling9-20261014-v2",
+    "dataset_count_with_float": 134,
+    "execution_host": "192.168.99.20",
+    "method_count": 9,
+    "mixed_dataset_method_pairs": 567,
+    "new_dataset_result_rows": 2412,
+    "old_results_retained": true,
+    "pair_count": 1206,
+    "public_overlay": {
+      "file": "float-scaling9-dataset-overlays.jsonl.gz",
+      "sha256": "027760f75a88dd8b91b658797855c3c5339ac74c7ef394105a37e4912f25afc7"
+    },
+    "pure_float_dataset_method_pairs": 639,
+    "schema": "float-scaling9-site-import-v1",
+    "timing_policy": "server192 float and pure-float overall only; mixed overall timing null; never enters server166-only figures"
+  },
   "measurement_runs": [
     {
       "decode_boundary": "DBF header parse, integer-body decode, and inverse scaling or IEEE-word reconstruction",
@@ -1003,6 +1054,28 @@
       "schema": "corrected-five425-site-import-v1",
       "special_support_review_pair_count": 8,
       "timing_admitted": false
+    },
+    {
+      "acceptance": {
+        "file": "FLOAT_SCALING9_SITE_ACCEPTANCE.json",
+        "sha256": "1a9cbcd4a2b38e770047734fa41f4b61c8f4919778fa80c53e11778a1e0db9e4"
+      },
+      "binary_sha256": "0558378c92fe855f666da67d4f712043df084838619f35af9e2ae40dc183c704",
+      "comparison_profile": "cpp-native192-float-scaling9-20261014-v2",
+      "dataset_count_with_float": 134,
+      "execution_host": "192.168.99.20",
+      "method_count": 9,
+      "mixed_dataset_method_pairs": 567,
+      "new_dataset_result_rows": 2412,
+      "old_results_retained": true,
+      "pair_count": 1206,
+      "public_overlay": {
+        "file": "float-scaling9-dataset-overlays.jsonl.gz",
+        "sha256": "027760f75a88dd8b91b658797855c3c5339ac74c7ef394105a37e4912f25afc7"
+      },
+      "pure_float_dataset_method_pairs": 639,
+      "schema": "float-scaling9-site-import-v1",
+      "timing_policy": "server192 float and pure-float overall only; mixed overall timing null; never enters server166-only figures"
     }
   ],
   "native86_imports": {