Update 26 C++ methods on 135 datasets with repaired results

Integrate 3,510 main26 conclusions and all Camel recovery overlays; preserve historical results. Publish complete numeric scopes, explicit partial/unsupported outcomes and original host/configuration provenance. Store large result snapshots with lossless gzip packaging to fit Space storage; numerical payloads are unchanged.

CPP135_MAIN26_AGGREGATE_RECEIPT.json

@@ -0,0 +1,96 @@
+{
+  "algorithm_independent_eligible_support_sha": "passed for every dataset with at least one full-support method",
+  "byte_boundary": "complete NGF1 frame bytes per input block; no outer P172 compound",
+  "column_method_rows": 91494,
+  "column_support_counts": {
+    "full_numeric": 56701,
+    "partial_support": 947,
+    "unsupported": 33846
+  },
+  "created_epoch_ns": 1792058561784005414,
+  "dataset_count": 135,
+  "dataset_method_rows": 3510,
+  "dataset_method_support_counts": {
+    "full_numeric": 1529,
+    "partial_support": 629,
+    "unsupported": 1352
+  },
+  "dsc2_excluded": true,
+  "eligible_support_sha_rule": "canonical SHA256 of sorted input manifest SHA256 values; populated only for full valid support",
+  "files": {
+    "COLUMN_RESULTS.jsonl.gz": {
+      "bytes": 15699577,
+      "sha256": "6c3d693556fb58f8277ac201dfe217ea85aec65489a707260af85981faa21e9b"
+    },
+    "DATASET_METHOD_RESULTS.jsonl.gz": {
+      "bytes": 457656,
+      "sha256": "5ba82d79f07327d6a5b2e1405d3f58db7e72930dcd0284132764ff48a8b5859b"
+    },
+    "selected_sources.json": {
+      "bytes": 1938310,
+      "sha256": "50cc9edd30e3d3a6c7314bf3f28bf16d0a56ce095f9849c2fccb4a7a470eebfc"
+    }
+  },
+  "input_manifest_binding": "raw manifest SHA256; every manifest embeds block_id, sequence SHA, values SHA, missing-bitmap SHA and counts",
+  "input_manifest_files_hashed": 3519,
+  "lossless_evidence": "producer built-in exact Block equality outside timed interval for every ok measurement; no independent fresh verifier is claimed",
+  "method_count": 26,
+  "methods": [
+    "2DIFF",
+    "ALP",
+    "BOS",
+    "BUFF",
+    "CORAD",
+    "Camel",
+    "Chimp",
+    "Chimp128",
+    "DBP",
+    "Elf",
+    "Elf+",
+    "FPC",
+    "FPCmp-R",
+    "FPCmp-S",
+    "FPZIP",
+    "FastPFor",
+    "Gorilla",
+    "LECO",
+    "PFPC",
+    "Pongo",
+    "REGER",
+    "RLBE",
+    "SPDP",
+    "SVB",
+    "Simple8b",
+    "Sprintz"
+  ],
+  "old_results_preserved": true,
+  "pre_enrichment_receipt_sha256": "80c59eb8bf4ac7ffc032490c2338251e81c0b186489fbb40cfdabee2f4971c3e",
+  "primary_metric": "arithmetic mean across nonempty columns; compression ratio and ns/valid-native-point are null unless whole dataset valid support",
+  "raw_evidence_roots": [
+    "/data/root/web_compression/cpp135_simple_remeasure_20261015_v1/attempt1",
+    "/data/root/web_compression/cpp135_192_simple_remeasure_20261015_v1/camel_recovery_v1/attempt1",
+    "/data/root/web_compression/cpp135_192_simple_remeasure_20261015_v1/camel_recovery_v2/attempt1",
+    "/data/root/web_compression/cpp135_192_simple_remeasure_20261015_v1/camel_recovery_v3/attempt1",
+    "/data/root/web_compression/cpp135_192_simple_remeasure_20261015_v1/camel_recovery_v4/attempt1"
+  ],
+  "raw_result_jsonl_read_rule": "each selected result JSONL is streamed exactly once; frame payloads are never read",
+  "row_status_counts": {
+    "N/A": 369985,
+    "ok": 11046868,
+    "unsupported": 3092057
+  },
+  "schema": "cpp135-main26-aggregate-receipt-v2",
+  "selected_key_sources": {
+    "base": 3136,
+    "recovery_v1": 119,
+    "recovery_v2": 51,
+    "recovery_v3": 34,
+    "recovery_v4": 170
+  },
+  "status": "complete_summarized_builtin_lossless_not_independent_fresh_verification",
+  "streamed_result_bytes": 32686714214,
+  "streamed_result_files": 7038,
+  "timing": "same server192 profile; W1/R3/T1; original float precision derivation charged once per method and column by producer",
+  "timing_scope_filter": "only ok/N-A measured-row timing scope retained; unsupported-only rows do not define timing",
+  "typed_route_contract_sha_rule": "separate canonical digest of configuration/profile/measured timing scope/implementation/CLI/runtime/terminal and NGF1 contract"
+}

CPP135_MAIN26_INPUT_SHA256SUMS.txt

@@ -0,0 +1,4 @@
+6c3d693556fb58f8277ac201dfe217ea85aec65489a707260af85981faa21e9b  COLUMN_RESULTS.jsonl.gz
+5ba82d79f07327d6a5b2e1405d3f58db7e72930dcd0284132764ff48a8b5859b  DATASET_METHOD_RESULTS.jsonl.gz
+50cc9edd30e3d3a6c7314bf3f28bf16d0a56ce095f9849c2fccb4a7a470eebfc  selected_sources.json
+f098925d8bd0b5718b102a8b6921b1234ced3baec80e2faeb47f2edb71c2d337  RECEIPT.json

CPP135_MAIN26_SITE_ACCEPTANCE.json

@@ -0,0 +1,90 @@
+{
+  "admission": {
+    "all_missing_frames": "all_missing_complete_frame_bytes is a subset of measured_complete_frame_bytes and is never added twice",
+    "lossless": "built-in bit-exact decode checks cover measured frames; no independent fresh-process verification claim",
+    "partial_and_terminal": "partial Overall never receives a numeric row; a completely supported dtype scope may remain numeric, while every absent scope has no old fallback",
+    "rate_bytes": "published only for a full_numeric Overall/integer/float scope as complete NGF1 frame bytes divided by original valid numeric bytes in that exact scope",
+    "timing": "published only for a full_numeric scope under one server-192 W1/R3/T1 column contract as equal-column arithmetic mean of ns per valid native-width point"
+  },
+  "aggregate_receipt": {
+    "file": "CPP135_MAIN26_AGGREGATE_RECEIPT.json",
+    "schema": "cpp135-main26-aggregate-receipt-v2",
+    "sha256": "f098925d8bd0b5718b102a8b6921b1234ced3baec80e2faeb47f2edb71c2d337",
+    "status": "complete_summarized_builtin_lossless_not_independent_fresh_verification"
+  },
+  "created_at": "2026-10-15T10:05:54.501279+00:00",
+  "dtype_scope_status_counts": {
+    "float": {
+      "numeric": 1936,
+      "partial_numeric": 193,
+      "unsupported": 1355
+    },
+    "integer": {
+      "numeric": 572,
+      "unsupported": 572
+    },
+    "overall": {
+      "numeric": 1529,
+      "partial_numeric": 629,
+      "unsupported": 1352
+    }
+  },
+  "inputs": {
+    "CPP135_MAIN26_AGGREGATE_RECEIPT.json": {
+      "bytes": 3683,
+      "sha256": "f098925d8bd0b5718b102a8b6921b1234ced3baec80e2faeb47f2edb71c2d337"
+    },
+    "CPP135_MAIN26_SELECTED_SOURCES.json": {
+      "bytes": 1938310,
+      "sha256": "50cc9edd30e3d3a6c7314bf3f28bf16d0a56ce095f9849c2fccb4a7a470eebfc"
+    },
+    "cpp135-main26-column-results.jsonl.gz": {
+      "bytes": 15699577,
+      "sha256": "6c3d693556fb58f8277ac201dfe217ea85aec65489a707260af85981faa21e9b"
+    },
+    "cpp135-main26-dataset-method-results.jsonl.gz": {
+      "bytes": 457656,
+      "sha256": "5ba82d79f07327d6a5b2e1405d3f58db7e72930dcd0284132764ff48a8b5859b"
+    }
+  },
+  "pair_status_counts": {
+    "numeric": 1529,
+    "partial_numeric": 629,
+    "unsupported": 1352
+  },
+  "schema": "compressionbenchmark-cpp135-main26-site-acceptance-v1",
+  "scope": {
+    "dataset_count": 135,
+    "method_count": 26,
+    "method_ids": [
+      "ALP",
+      "BUFF",
+      "CORAD",
+      "Camel",
+      "Chimp",
+      "Chimp128",
+      "Elf",
+      "Elf+",
+      "FPC",
+      "FPCmp-R",
+      "FPCmp-S",
+      "FPZIP",
+      "Gorilla",
+      "PFPC",
+      "Pongo",
+      "SPDP",
+      "Sprintz",
+      "2DIFF",
+      "BOS",
+      "DBP",
+      "FastPFor",
+      "LECO",
+      "REGER",
+      "RLBE",
+      "SVB",
+      "Simple8b"
+    ],
+    "pair_count": 3510
+  },
+  "status": "accepted_completed_builtin_bitexact"
+}

CPP135_MAIN26_SITE_INTEGRATION.json

@@ -0,0 +1,147 @@
+{
+  "candidate_revision": "v4_gzip_transport_manifest_closure",
+  "created_at": "2026-10-15T10:29:23.734229+00:00",
+  "files": {
+    "CPP135_MAIN26_AGGREGATE_RECEIPT.json": {
+      "bytes": 3683,
+      "sha256": "f098925d8bd0b5718b102a8b6921b1234ced3baec80e2faeb47f2edb71c2d337"
+    },
+    "CPP135_MAIN26_INPUT_SHA256SUMS.txt": {
+      "bytes": 355,
+      "sha256": "24d6eec79a4e09cd0e8c9819dc23d9723812867158869d7214caf0f1b9a75c24"
+    },
+    "CPP135_MAIN26_SELECTED_SOURCES.json": {
+      "bytes": 1938310,
+      "sha256": "50cc9edd30e3d3a6c7314bf3f28bf16d0a56ce095f9849c2fccb4a7a470eebfc"
+    },
+    "CPP135_MAIN26_SITE_ACCEPTANCE.json": {
+      "bytes": 2860,
+      "sha256": "e99fdac1f870174c520a2a2fae643ca4259a33afb4feffd0e849a5a302ad91cd"
+    },
+    "README.md": {
+      "bytes": 4188,
+      "sha256": "c89a678703ff26d46f676a8bb807aff3da30c74961c21063ea277307c8e8af99"
+    },
+    "app.js": {
+      "bytes": 69465,
+      "sha256": "39ca6b54fb0dcc0b722f0a84ea7e5175151de0225bfb65d4e40b53cf54fc204a"
+    },
+    "build_gzip_storage_recovery.py": {
+      "bytes": 17650,
+      "sha256": "5ae7e125c6aab30f95cd6c05681111dfec9a94832ec44181491134a0d33ae401"
+    },
+    "build_main26_site.py": {
+      "bytes": 59034,
+      "sha256": "0112b3121303e361b319791c3fbf5d8c230e3636fd1f7ce5197e9ccacc4712d9"
+    },
+    "cpp-latest-view-main26.json.gz": {
+      "bytes": 837481,
+      "sha256": "818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180"
+    },
+    "cpp135-main26-column-results.jsonl.gz": {
+      "bytes": 15699577,
+      "sha256": "6c3d693556fb58f8277ac201dfe217ea85aec65489a707260af85981faa21e9b"
+    },
+    "cpp135-main26-dataset-method-results.jsonl.gz": {
+      "bytes": 457656,
+      "sha256": "5ba82d79f07327d6a5b2e1405d3f58db7e72930dcd0284132764ff48a8b5859b"
+    },
+    "data-main26.json.gz": {
+      "bytes": 10041708,
+      "sha256": "7a00869fc545f1f2cb7a6c7bd2a6f72e12eddc7361edc68925d3b4bd04ac28a8"
+    },
+    "index.html": {
+      "bytes": 17814,
+      "sha256": "3a788a52e1ff441a3782aef8b34d3aaf77cc24424a7a3286c659f46a9717d2e8"
+    },
+    "manifest.json": {
+      "bytes": 95687,
+      "sha256": "15d2d18dd65f2c811a88149dd12c8ca3dd3b1089d7b4b8723f6767c823734ba0"
+    },
+    "ui-data.json": {
+      "bytes": 9697244,
+      "sha256": "841b15cbef0c346b43d72ab3c9530065abe4d24c45aef64d5e75d8ec49996f8f"
+    }
+  },
+  "final_dataset_result_count": 99008,
+  "historical_dataset_results_canonical_sha256": "213ac4e2c2d53801095316040d633cfd9541055ffc939b62a5b46ab95f442547",
+  "new_dataset_result_count": 4037,
+  "old_dataset_result_count": 94971,
+  "page_checks_required_after_publication": [
+    "C++ Overall uses the latest main26 decision for all exact 135 x 26 pairs",
+    "full-support rows show server-192 provenance and one W1/R3/T1 timing contract",
+    "partial, unsupported and not-applicable pairs do not fall back to old numeric rows",
+    "CSV retains source host, binary/support identity, measurement status and timing status"
+  ],
+  "parent_revision": "963f2ff216fd95ffba42d625a12765169eb4d850",
+  "publication_file_list": [
+    "data-main26.json.gz",
+    "ui-data.json",
+    "cpp-latest-view-main26.json.gz",
+    "app.js",
+    "index.html",
+    "README.md",
+    "manifest.json",
+    "build_gzip_storage_recovery.py",
+    "cpp135-main26-column-results.jsonl.gz",
+    "cpp135-main26-dataset-method-results.jsonl.gz",
+    "CPP135_MAIN26_SELECTED_SOURCES.json",
+    "CPP135_MAIN26_AGGREGATE_RECEIPT.json",
+    "CPP135_MAIN26_INPUT_SHA256SUMS.txt",
+    "CPP135_MAIN26_SITE_ACCEPTANCE.json",
+    "build_main26_site.py",
+    "CPP135_MAIN26_SITE_INTEGRATION.json"
+  ],
+  "schema": "compressionbenchmark-cpp135-main26-site-integration-v1",
+  "scope": {
+    "measured_datasets": 135,
+    "methods": 26,
+    "pair_count": 3510,
+    "pair_status_counts": {
+      "numeric": 1529,
+      "partial_numeric": 629,
+      "unsupported": 1352
+    }
+  },
+  "semantic_checks": {
+    "all_3510_latest_pair_decisions_replaced": true,
+    "app_javascript_syntax": "pass",
+    "compressed_bytes_include_NA_frames_once": true,
+    "data_ui_sidecar_hash_closure": true,
+    "gzip_packager_source_published": true,
+    "gzip_transport_decompresses_byte_exact_to_canonical_v2_payload": true,
+    "historical_rows_retained_byte_for_byte_in_canonical_order": true,
+    "large_uncompressed_data_and_sidecar_excluded_from_publication_delta": true,
+    "latest_page_never_reads_legacy_large_files": true,
+    "manifest_exact_file_transport_and_legacy_closure": true,
+    "numeric_rows_only_for_full_valid_support_within_exact_dtype_scope": true,
+    "partial_overall_never_published_but_full_dtype_scope_retained": true,
+    "partial_unsupported_not_applicable_numeric_fallback_count": 0,
+    "ranking_js_unchanged": true,
+    "readme_main26_scope_and_measurement_contract_updated": true
+  },
+  "status": "passed_not_published",
+  "storage_plan": {
+    "estimated_remaining_after_files_before_integration": 77713466,
+    "excluded_uncompressed_bytes": 185591944,
+    "official_limit_bytes": 1000000000,
+    "official_remaining_bytes_before": 116656178,
+    "official_used_bytes_before": 883343822,
+    "publication_delta_bytes": 38942712,
+    "transport_files": {
+      "cpp_latest_view": {
+        "encoding": "gzip",
+        "file": "cpp-latest-view-main26.json.gz",
+        "sha256": "818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180",
+        "uncompressed_sha256": "f1aef2f23a0374e43ddde18d5ab2b29095ff344cf9ef4d591cd8037e55958a6e"
+      },
+      "data": {
+        "encoding": "gzip",
+        "file": "data-main26.json.gz",
+        "sha256": "7a00869fc545f1f2cb7a6c7bd2a6f72e12eddc7361edc68925d3b4bd04ac28a8",
+        "uncompressed_sha256": "e7f7a9f294c1a94aec0e8271c62308f499286cbe9bd2333a6fe685f0839cabb2"
+      }
+    }
+  },
+  "supersedes_candidate": "candidate_main26_v3"
+}

README.md

@@ -17,7 +17,7 @@ The active test scope contains **137 datasets** and 85 active C++ method familie
 
 C++ selects the latest receipt-bound authority per dataset and canonical method. Its active comparison is restricted to the 85 method contract; two extra historical methods remain in raw downloads. Java/Python retain their published source profiles. Numeric dtype-specific results, terminal N/A, unsupported and retest-pending states remain distinct. Overall method cells contain only the method/configuration name; details explain coverage and retain provenance. CSV includes source hosts, support sets, timing admission and the active scope.
 
-Compression rate remains complete compressed-frame bytes divided by original numeric binary bytes. The three shared CSV metadata files are not added to the compressed numerator. No ratio is inverted, clipped or altered. `ranking.js`, the raw data, compact data, manifests and source selection evidence are unchanged. Cross-host/campaign timing is not pooled into strict rankings; admitted timed subsets remain explicitly labeled and do not enter strict composite scores.
+Compression rate remains complete compressed-frame bytes divided by original numeric binary bytes. The three shared CSV metadata files are not added to the compressed numerator. No ratio is inverted, clipped or altered. `ranking.js` is unchanged. The latest C++ view imports the completed server-192 main26 campaign plus four exact-disjoint Camel recovery selections: 3,510 dataset-method conclusions across 135 measured datasets (within the 137-dataset catalog and 85 active-family contract), comprising 1,529 full-support, 629 partial-support and 1,352 unsupported conclusions and 4,037 numeric Overall/integer/float scope rows. Compression and decompression timing uses the same-host W1/R3/T1 contract; compression bytes are complete NGF1 frames per input block, and every measured `ok` frame passed built-in bit-exact Block equality outside the timed interval. This does not claim independent fresh-process verification. No cross-host timing is mixed in the new rows. Updated raw compact results, the publication manifest and source-selection evidence are bound by the Main26 receipts. To keep the append-only Space below its storage limit, the canonical full result snapshot and latest-view sidecar are published as deterministic gzip transports; their compressed and decompressed SHA-256 values are frozen. The earlier `data.json` and `cpp-latest-view.json` objects remain immutable historical artifacts; the latest page reads `ui-data.json` and the SHA-verified `cpp-latest-view-main26.json.gz` sidecar, while its snapshot download points to `data-main26.json.gz`. Cross-host/campaign timing is not pooled into strict rankings; admitted timed subsets remain explicitly labeled and do not enter strict composite scores.
 
 Historical operator byte effects are retained as diagnostics. Current-scope, corrected-input operator results remain pending and must be independently accepted before replacing them. Dataset corrections are documented in `FINAL160_FORMAT_AUDIT.json`; its previous 160-dataset investigation is a historical parent-scope audit, not the active selection list.
 

app.js

@@ -1,7 +1,8 @@
 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='564b8f7760a6336e93bd0d69601e74ada9819b361dc2464d768689af0d287cbd';
+const CPP_LATEST_VIEW_SHA256='f1aef2f23a0374e43ddde18d5ab2b29095ff344cf9ef4d591cd8037e55958a6e';
+const CPP_LATEST_VIEW_GZIP_SHA256='818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180';
 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;
@@ -383,7 +384,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_baseline_and_accepted_float_scaling9')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_verified_live_float9_baseline_and_completed_main26')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.');
@@ -462,10 +463,13 @@ void loadReferenceCatalog();
 void loadOperatorEffect();
 void loadDatasetCatalog();
 async function sha256Hex(buffer){const digest=await crypto.subtle.digest('SHA-256',buffer);return [...new Uint8Array(digest)].map(byte=>byte.toString(16).padStart(2,'0')).join('');}
+async function gunzipBuffer(buffer,label){if(typeof DecompressionStream!=='function')throw new Error(`${label} requires browser gzip decompression support.`);try{return await new Response(new Blob([buffer]).stream().pipeThrough(new DecompressionStream('gzip'))).arrayBuffer();}catch(error){throw new Error(`${label} could not be decompressed: ${error instanceof Error?error.message:String(error)}`);}}
 try {
-  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'})]);
+  const [snapshotResponse,sidecarResponse]=await Promise.all([fetch('./ui-data.json?v=20261015-main26-gzip-v4',{cache:'no-cache'}),fetch('./cpp-latest-view-main26.json.gz?v=20261015-main26-gzip-v4',{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 [snapshotBuffer,sidecarGzipBuffer]=await Promise.all([snapshotResponse.arrayBuffer(),sidecarResponse.arrayBuffer()]);
+  const sidecarGzipSha=await sha256Hex(sidecarGzipBuffer);if(sidecarGzipSha!==CPP_LATEST_VIEW_GZIP_SHA256)throw new Error('The compressed C++ sidecar transport does not match the frozen release.');
+  const sidecarBuffer=await gunzipBuffer(sidecarGzipBuffer,'The combined C++ sidecar');
   const sidecarSha=await sha256Hex(sidecarBuffer);if(sidecarSha!==CPP_LATEST_VIEW_SHA256)throw new Error('The combined C++ sidecar does not match the independently reviewed release selection.');
   const sidecarValue=JSON.parse(new TextDecoder().decode(sidecarBuffer));
   const snapshotSha=await sha256Hex(snapshotBuffer);if(snapshotSha!==sidecarValue?.baseline?.ui_data_sha256)throw new Error('The combined C++ sidecar is not bound to this exact UI snapshot.');

build_main26_site.py

@@ -0,0 +1,927 @@
+#!/usr/bin/env python3
+"""Integrate the completed 26 x 135 server-192 campaign into the C++ latest view.
+
+The published snapshot is append-only: historical result rows and every
+non-target latest-view decision are preserved.  The 3,510 target decisions are
+replaced atomically.  Overall metrics require complete valid-value support;
+integer/float rows require complete support inside that exact dtype scope.
+Partial and terminal conclusions never inherit an older numeric result.
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+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
+
+
+BASELINE_REVISION = "963f2ff216fd95ffba42d625a12765169eb4d850"
+BASELINE_SHA256 = {
+    "data.json": "3c66633b2d58b126edfad8afe173caf1f53fbcdb6f7b205c3d51b42dfc75a241",
+    "ui-data.json": "c3c7103e47e0d61225839d9fd63f1b9d3757cf519a578c41ef9c81be46f3534d",
+    "cpp-latest-view.json": "564b8f7760a6336e93bd0d69601e74ada9819b361dc2464d768689af0d287cbd",
+    "manifest.json": "5d2d09c0f4f0f7b057fe3733e737b4b4dd9be06e4c524199167f30fe9c26c3ee",
+    "app.js": "bb92e7beda5f51bda2251e3b82ba324f38f9eed4b7b0e0edb35921d6d6c692f1",
+    "index.html": "2dac927226504d65ca4def06adb76154e737e29a16ae6ac7db64f478d78af5ce",
+    "ranking.js": "6e14543b42050ec7ad6a04948e8abd6f3589c477035708f9d01814d05a16c076",
+    "final-dataset-scope.json": "b56f9bd610e0bf63ab50d719ce70cf92ddc1b79e6b30fd2c6e2f707944b2ba72",
+    "final-input-status.json": "07aef0e1503fbc1cc3bed267ccb3d4e1f613a12c25fbf6166be97b5234cb0520",
+}
+METHODS = (
+    "ALP", "BUFF", "CORAD", "Camel", "Chimp", "Chimp128", "Elf", "Elf+",
+    "FPC", "FPCmp-R", "FPCmp-S", "FPZIP", "Gorilla", "PFPC", "Pongo",
+    "SPDP", "Sprintz", "2DIFF", "BOS", "DBP", "FastPFor", "LECO", "REGER",
+    "RLBE", "SVB", "Simple8b",
+)
+METHOD_SET = set(METHODS)
+EXPECTED_PAIR_COUNT = 135 * len(METHODS)
+PROFILE = "cpp-native192-main26-whole-column-20261015-v1"
+VERSION = "20261015-main26-gzip-v4"
+SIDECAR_STATUS = "built_from_verified_live_float9_baseline_and_completed_main26"
+README_OLD = "`ranking.js`, the raw data, compact data, manifests and source selection evidence are unchanged."
+README_NEW = (
+    "`ranking.js` is unchanged. The latest C++ view imports the completed server-192 main26 campaign "
+    "plus four exact-disjoint Camel recovery selections: 3,510 dataset-method conclusions across 135 "
+    "measured datasets (within the 137-dataset catalog and 85 active-family contract), comprising 1,529 "
+    "full-support, 629 partial-support and 1,352 unsupported conclusions and 4,037 numeric "
+    "Overall/integer/float scope rows. Compression and decompression timing uses the same-host W1/R3/T1 "
+    "contract; compression bytes are complete NGF1 frames per input block, and every measured `ok` frame "
+    "passed built-in bit-exact Block equality outside the timed interval. This does not claim independent "
+    "fresh-process verification. No cross-host timing is mixed in the new rows. Updated raw compact results, "
+    "the publication manifest and source-selection evidence are bound by the Main26 receipts. To keep the "
+    "append-only Space below its storage limit, the canonical full result snapshot and latest-view sidecar are "
+    "published as deterministic gzip transports; their compressed and decompressed SHA-256 values are frozen. "
+    "The earlier `data.json` and `cpp-latest-view.json` objects remain immutable historical artifacts; the latest "
+    "page reads `ui-data.json` and the SHA-verified `cpp-latest-view-main26.json.gz` sidecar, while its snapshot "
+    "download points to `data-main26.json.gz`."
+)
+DATA_GZIP = "data-main26.json.gz"
+SIDECAR_GZIP = "cpp-latest-view-main26.json.gz"
+GZIP_PACKAGER = "build_gzip_storage_recovery.py"
+
+SOURCE_FILES = {
+    "COLUMN_RESULTS.jsonl.gz": "cpp135-main26-column-results.jsonl.gz",
+    "DATASET_METHOD_RESULTS.jsonl.gz": "cpp135-main26-dataset-method-results.jsonl.gz",
+    "selected_sources.json": "CPP135_MAIN26_SELECTED_SOURCES.json",
+    "RECEIPT.json": "CPP135_MAIN26_AGGREGATE_RECEIPT.json",
+    "SHA256SUMS": "CPP135_MAIN26_INPUT_SHA256SUMS.txt",
+}
+PUBLIC_ACCEPTANCE = "CPP135_MAIN26_SITE_ACCEPTANCE.json"
+PUBLIC_INTEGRATION = "CPP135_MAIN26_SITE_INTEGRATION.json"
+
+
+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 deterministic_gzip(source: Path, target: Path) -> None:
+    with source.open("rb") as src, target.open("wb") as raw:
+        with gzip.GzipFile(filename="", mode="wb", fileobj=raw, compresslevel=9, mtime=0) as zipped:
+            shutil.copyfileobj(src, zipped, length=8 << 20)
+
+
+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_gzip_jsonl(path: Path) -> list[dict[str, Any]]:
+    with gzip.open(path, "rt", encoding="utf-8") as stream:
+        rows = [json.loads(line) for line in stream 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 parse_sha256sums(path: Path) -> dict[str, str]:
+    result: dict[str, str] = {}
+    for line in path.read_text().splitlines():
+        if not line.strip():
+            continue
+        digest, name = line.split(maxsplit=1)
+        name = name.lstrip("* ")
+        require(len(digest) == 64 and name not in result, f"invalid SHA256SUMS row: {line}")
+        result[name] = digest
+    return result
+
+
+def finite_number(value: Any, *, nonnegative: bool = True) -> float:
+    require(type(value) in (int, float) and math.isfinite(float(value)), f"non-finite number: {value!r}")
+    number = float(value)
+    require(not nonnegative or number >= 0, f"negative number: {value!r}")
+    return number
+
+
+def measured_datasets(baseline: Path) -> set[str]:
+    scope = read_json(baseline / "final-dataset-scope.json")
+    status = read_json(baseline / "final-input-status.json")
+    pending = {str(item["dataset_id"]) for item in status["pending_datasets"]}
+    result = {str(item) for item in scope["datasets"]} - pending
+    require(len(scope["datasets"]) == 137 and len(pending) == 2 and len(result) == 135, "published 137/135 dataset scope changed")
+    return result
+
+
+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 pair_status(row: dict[str, Any]) -> str:
+    status = str(row["support_state"])
+    require(status in {"full_numeric", "partial_support", "unsupported", "not_applicable"}, f"unknown support_state: {status}")
+    full = row.get("full_valid_support") is True
+    supported = int(row["supported_valid_value_count"])
+    unsupported = int(row["unsupported_valid_value_count"])
+    ratio = row.get("compression_ratio")
+    if status == "full_numeric":
+        require(full and supported > 0 and unsupported == 0 and ratio is not None, "invalid full_numeric pair")
+        return "numeric"
+    require(ratio is None, f"non-full pair exposes a publishable ratio: {status}")
+    if status == "partial_support":
+        require(supported > 0 and unsupported > 0, "invalid partial support pair")
+        return "partial_numeric"
+    if status == "unsupported":
+        require(supported == 0 and unsupported > 0, "invalid unsupported pair")
+        return "unsupported"
+    require(full and supported == 0 and unsupported == 0, "not_applicable pair has valid values or an invalid support flag")
+    return "not_applicable"
+
+
+def single_string(row: dict[str, Any], field: str) -> str:
+    value = row[field]
+    values = [value] if isinstance(value, str) else list(value)
+    require(len(values) == 1 and isinstance(values[0], str) and values[0], f"{field} is not one exact value")
+    return values[0]
+
+
+def string_set(row: dict[str, Any], field: str) -> list[str]:
+    value = row[field]
+    values = [value] if isinstance(value, str) else list(value)
+    require(values and all(isinstance(item, str) and item for item in values), f"{field} has an empty or non-string value")
+    require(len(values) == len(set(values)), f"{field} has duplicate values")
+    return sorted(values)
+
+
+def dtype_scope(dtype: str) -> str:
+    normalized = dtype.lower()
+    if normalized.startswith(("int", "uint")):
+        return "integer"
+    if normalized.startswith("float"):
+        return "float"
+    raise ValueError(f"unsupported numeric dtype for website scope: {dtype}")
+
+
+def build_support_sha(column_rows: list[dict[str, Any]], scope: str) -> str:
+    """Hash only the algorithm-independent workload cohort used for ranking.
+
+    Runtime, method, terminal, configuration and wire-format identity belong to
+    ``typed_route_contract_sha`` below.  Keeping them out of this digest makes
+    two codecs comparable when they cover the exact same frozen typed columns.
+    """
+    manifest_hashes = []
+    for row in column_rows:
+        dataset = str(row.get("dataset_id") or row.get("dataset"))
+        column = str(row.get("column_key") or row.get("column_id") or row.get("column"))
+        require(dataset and column and column != "None", "column row lacks exact workload identity")
+        digest = row.get("input_manifest_sha256")
+        require(isinstance(digest, str) and len(digest) == 64, f"input manifest SHA missing: {dataset}/{scope}/{column}")
+        manifest_hashes.append(digest)
+    # Each content-addressed manifest embeds column identity/dtype, block IDs,
+    # sequence/value/missing-bitmap SHAs and counts.  Selecting the manifests
+    # for this scope supplies the scope separation without method provenance.
+    return canonical_sha(sorted(manifest_hashes))
+
+
+def typed_route_contract_sha(column_rows: list[dict[str, Any]]) -> str:
+    digests = []
+    for row in column_rows:
+        digest = row.get("typed_route_contract_sha256")
+        require(isinstance(digest, str) and len(digest) == 64, "column typed-route contract SHA missing")
+        digests.append(digest)
+    return canonical_sha(sorted(digests))
+
+
+def typed_route(column_rows: list[dict[str, Any]]) -> dict[str, Any]:
+    entries: dict[tuple[str, str, str], dict[str, Any]] = {}
+    binary_values = {str(row["runtime_binary_sha256"]) for row in column_rows}
+    require(len(binary_values) == 1, "typed route crosses runtime binaries")
+    for row in column_rows:
+        dtype = str(row["dtype"])
+        scope = dtype_scope(dtype)
+        configuration = single_string(row, "configurations")
+        profile = single_string(row, "profile_versions")
+        cli_values = string_set(row, "producer_cli_sha256") if row.get("producer_cli_sha256") else []
+        require(len(cli_values) <= 1, "one column uses multiple producer CLIs")
+        timing_scopes = string_set(row, "timing_scopes") if row.get("timing_scopes") else []
+        require(len(timing_scopes) <= 1, "one column has multiple measured timing scopes")
+        key = dtype, configuration, profile
+        entry = entries.setdefault(key, {
+            "dtype": dtype,
+            "dtype_scope": scope,
+            "configuration": configuration,
+            "profile_version": profile,
+            "producer_cli_sha256": set(),
+            "timing_scopes": set(),
+            "precision_semantics": set(),
+            "column_count": 0,
+            "precision_charge_rows": 0,
+        })
+        entry["producer_cli_sha256"].update(cli_values)
+        entry["timing_scopes"].update(timing_scopes)
+        entry["precision_semantics"].update(string_set(row, "precision_semantics") if row.get("precision_semantics") else [])
+        entry["column_count"] += 1
+        entry["precision_charge_rows"] += int(row.get("precision_charge_rows", 0))
+    routes = []
+    for entry in entries.values():
+        require(len(entry["producer_cli_sha256"]) <= 1, "one typed route uses multiple producer CLIs")
+        require(len(entry["timing_scopes"]) <= 1, "one typed route uses multiple measured timing scopes")
+        routes.append({
+            **entry,
+            "producer_cli_sha256": sorted(entry["producer_cli_sha256"]),
+            "timing_scopes": sorted(entry["timing_scopes"]),
+            "precision_semantics": sorted(entry["precision_semantics"]),
+        })
+    routes.sort(key=lambda item: (item["dtype_scope"], item["dtype"], item["configuration"], item["profile_version"]))
+    return {
+        "routes": routes,
+        "configurations": sorted({item["configuration"] for item in routes}),
+        "profile_versions": sorted({item["profile_version"] for item in routes}),
+        "producer_cli_sha256": sorted({value for item in routes for value in item["producer_cli_sha256"]}),
+        "runtime_binary_sha256": next(iter(binary_values)),
+    }
+
+
+def scoped_summary(source: dict[str, Any], column_rows: list[dict[str, Any]], scope: str) -> dict[str, Any]:
+    require(scope in {"overall", "integer", "float"}, f"unknown dtype scope: {scope}")
+    selected = list(column_rows) if scope == "overall" else [row for row in column_rows if dtype_scope(str(row["dtype"])) == scope]
+    require(selected, f"cannot summarize absent scope: {source['dataset_id']}/{source['method']}/{scope}")
+    supported = sum(int(row["supported_valid_value_count"]) for row in selected)
+    unsupported = sum(int(row["unsupported_valid_value_count"]) for row in selected)
+    full_columns = [row for row in selected if row["support_state"] == "full_numeric"]
+    if supported and not unsupported:
+        status = "full_numeric"
+    elif supported and unsupported:
+        status = "partial_support"
+    elif unsupported:
+        status = "unsupported"
+    else:
+        status = "not_applicable"
+    numeric = status == "full_numeric"
+    original = sum(int(row["supported_original_numeric_bytes"]) for row in selected)
+    compressed = sum(int(row["measured_complete_frame_bytes"]) for row in selected)
+    ratios = [finite_number(row["compression_ratio"]) for row in full_columns]
+    cpps = [finite_number(row["compression_ns_per_valid_native_point"]) for row in full_columns]
+    dpps = [finite_number(row["decompression_ns_per_valid_native_point"]) for row in full_columns]
+    result = {
+        **{key: source[key] for key in ("dataset_id", "method", "family", "method_family", "selected_source", "runtime_binary_sha256", "selected_terminal_sha256")},
+        "scope": scope,
+        "support_state": status,
+        "full_valid_support": unsupported == 0,
+        "column_count": len(selected),
+        "full_numeric_columns": len(full_columns),
+        "partial_support_columns": sum(row["support_state"] == "partial_support" for row in selected),
+        "unsupported_columns": sum(row["support_state"] == "unsupported" for row in selected),
+        "not_applicable_columns": sum(row["support_state"] == "not_applicable" for row in selected),
+        "supported_valid_value_count": supported,
+        "unsupported_valid_value_count": unsupported,
+        "supported_original_numeric_bytes": original,
+        "unsupported_original_numeric_bytes": sum(int(row["unsupported_original_numeric_bytes"]) for row in selected),
+        "measured_complete_frame_bytes": compressed,
+        "all_missing_complete_frame_bytes": sum(int(row["all_missing_complete_frame_bytes"]) for row in selected),
+        "compression_ratio": statistics.fmean(ratios) if numeric and ratios else None,
+        "compression_ratio_column_arithmetic_mean": statistics.fmean(ratios) if numeric and ratios else None,
+        "secondary_pooled_compression_ratio": compressed / original if numeric and original else None,
+        "compression_ns_per_valid_native_point_column_arithmetic_mean": statistics.fmean(cpps) if numeric and cpps else None,
+        "decompression_ns_per_valid_native_point_column_arithmetic_mean": statistics.fmean(dpps) if numeric and dpps else None,
+        "profile_versions": sorted({item for row in selected for item in string_set(row, "profile_versions")}),
+        "configurations": sorted({item for row in selected for item in string_set(row, "configurations")}),
+        "producer_cli_sha256": sorted({item for row in selected for item in (string_set(row, "producer_cli_sha256") if row.get("producer_cli_sha256") else [])}),
+        "byte_boundary": "sum complete NGF1 frame bytes over selected dtype-scope columns / original valid numeric bytes",
+        "timing_contract": "arithmetic mean of per-column ns/valid-native-point; W1/R3/T1; built-in exact Block equality outside timed interval",
+        "typed_route": typed_route(selected),
+    }
+    result["support_sha256"] = build_support_sha(selected, scope)
+    result["typed_route_contract_sha256"] = typed_route_contract_sha(selected)
+    if scope == "overall":
+        for field in (
+            "support_state", "full_valid_support", "column_count", "full_numeric_columns", "partial_support_columns",
+            "unsupported_columns", "not_applicable_columns", "supported_valid_value_count", "unsupported_valid_value_count",
+            "supported_original_numeric_bytes", "unsupported_original_numeric_bytes", "measured_complete_frame_bytes",
+            "all_missing_complete_frame_bytes", "profile_versions", "configurations", "producer_cli_sha256",
+        ):
+            require(result[field] == source[field], f"column-derived overall field differs: {source['dataset_id']}/{source['method']}/{field}")
+        for field in (
+            "compression_ratio_column_arithmetic_mean", "secondary_pooled_compression_ratio",
+            "compression_ns_per_valid_native_point_column_arithmetic_mean", "decompression_ns_per_valid_native_point_column_arithmetic_mean",
+        ):
+            left, right = result[field], source[field]
+            require((left is None and right is None) or math.isclose(finite_number(left), finite_number(right), rel_tol=2e-12), f"column-derived overall metric differs: {source['dataset_id']}/{source['method']}/{field}")
+    return result
+
+
+def validate_inputs(aggregate: Path, datasets: set[str]) -> tuple[list[dict[str, Any]], dict[tuple[str, str], dict[str, dict[str, Any]]], dict[str, Any], dict[str, str]]:
+    for source in SOURCE_FILES:
+        require((aggregate / source).is_file(), f"missing aggregate input: {source}")
+    sums = parse_sha256sums(aggregate / "SHA256SUMS")
+    for source in SOURCE_FILES:
+        if source == "SHA256SUMS":
+            continue
+        require(sums.get(source) == sha256(aggregate / source), f"aggregate SHA mismatch: {source}")
+    receipt = read_json(aggregate / "RECEIPT.json")
+    require(str(receipt.get("status", "")).startswith(("complete", "passed", "accepted")), "aggregate receipt is not terminal-complete")
+    require(receipt.get("schema") == "cpp135-main26-aggregate-receipt-v2", "aggregate receipt schema differs")
+    require(int(receipt.get("dataset_count", -1)) == 135 and int(receipt.get("method_count", -1)) == 26 and int(receipt.get("dataset_method_rows", -1)) == EXPECTED_PAIR_COUNT, "aggregate receipt scope differs")
+    receipt_files = receipt.get("files") or {}
+    for name in ("COLUMN_RESULTS.jsonl.gz", "DATASET_METHOD_RESULTS.jsonl.gz", "selected_sources.json"):
+        require((receipt_files.get(name) or {}).get("sha256") == sums[name], f"aggregate receipt file binding differs: {name}")
+    selected_sources = read_json(aggregate / "selected_sources.json")
+    rows = read_gzip_jsonl(aggregate / "DATASET_METHOD_RESULTS.jsonl.gz")
+    columns = read_gzip_jsonl(aggregate / "COLUMN_RESULTS.jsonl.gz")
+    require(len(rows) == EXPECTED_PAIR_COUNT, f"expected {EXPECTED_PAIR_COUNT} dataset-method rows")
+    identities = {(str(row["dataset_id"]), str(row["method"])) for row in rows}
+    require(len(identities) == EXPECTED_PAIR_COUNT, "duplicate dataset-method result")
+    require({dataset for dataset, _ in identities} == datasets, "aggregate dataset scope differs from published measured135")
+    require({method for _, method in identities} == METHOD_SET, "aggregate method scope differs from exact main26")
+    source_keys = selected_sources.get("keys")
+    require(selected_sources.get("schema") == "cpp135-main26-selected-sources-v1" and isinstance(source_keys, list) and len(source_keys) == EXPECTED_PAIR_COUNT, "selected source map differs")
+    source_by_pair = {(str(item["dataset_id"]), str(item["method"])): item for item in source_keys}
+    require(len(source_by_pair) == EXPECTED_PAIR_COUNT and set(source_by_pair) == identities, "selected source identity set differs")
+
+    grouped_columns: dict[tuple[str, str], list[dict[str, Any]]] = defaultdict(list)
+    for row in columns:
+        dataset = str(row.get("dataset_id") or row.get("dataset"))
+        method = str(row.get("method") or row.get("family"))
+        require((dataset, method) in identities, f"out-of-scope column result: {dataset}/{method}")
+        grouped_columns[dataset, method].append(row)
+    scoped: dict[tuple[str, str], dict[str, dict[str, Any]]] = {}
+    for row in rows:
+        key = str(row["dataset_id"]), str(row["method"])
+        require(str(row.get("family") or row["method"]) == key[1], f"family alias differs: {key}")
+        require(str(row["method_family"]) in {"native17_original_dtype", "scaled9_decimal_int64_v1"}, f"method_family differs: {key}")
+        require(len(grouped_columns[key]) == int(row["column_count"]), f"column count differs: {key}")
+        pair_status(row)
+        require(int(row["ok_blocks"]) + int(row["not_applicable_blocks"]) + int(row["unsupported_blocks"]) == int(row["block_rows"]), f"block terminal count differs: {key}")
+        require(int(row["full_numeric_columns"]) + int(row["partial_support_columns"]) + int(row["unsupported_columns"]) + int(row["not_applicable_columns"]) == int(row["column_count"]), f"column terminal count differs: {key}")
+        require(int(row["measured_complete_frame_bytes"]) >= int(row["all_missing_complete_frame_bytes"]) >= 0, f"N/A frame bytes differ: {key}")
+        producer_cli = string_set(row, "producer_cli_sha256") if row.get("producer_cli_sha256") else []
+        require(len(producer_cli) <= 1 and all(len(value) == 64 for value in producer_cli) and len(str(row["runtime_binary_sha256"])) == 64, f"runtime binding missing: {key}")
+        selected = source_by_pair[key]
+        require(selected.get("source_label") == row["selected_source"], f"selected source label differs: {key}")
+        require(selected.get("binary_sha256") == row["runtime_binary_sha256"], f"selected binary differs: {key}")
+        require(selected.get("terminal_sha256") == row["selected_terminal_sha256"], f"selected terminal differs: {key}")
+        pair_columns = grouped_columns[key]
+        for column in pair_columns:
+            require(column.get("schema") == "cpp135-main26-column-v1", f"column schema differs: {key}")
+            require(column["runtime_binary_sha256"] == row["runtime_binary_sha256"], f"column binary differs: {key}")
+            require(column["selected_terminal_sha256"] == row["selected_terminal_sha256"], f"column terminal differs: {key}")
+            require(column["selected_source"] == row["selected_source"], f"column selected source differs: {key}")
+            require(column["timing_contract"] == "W1/R3/T1; median of three aligned block sums; built-in exact Block equality outside timed interval", f"column timing contract differs: {key}")
+            require(column["byte_boundary"] == "sum complete NGF1 frame bytes per measured input block / original valid numeric bytes", f"column byte boundary differs: {key}")
+            column_cli = string_set(column, "producer_cli_sha256") if column.get("producer_cli_sha256") else []
+            require(len(column_cli) <= 1 and all(len(value) == 64 for value in column_cli), f"column producer CLI differs: {key}")
+            single_string(column, "profile_versions")
+            single_string(column, "configurations")
+            timing_scopes = string_set(column, "timing_scopes") if column.get("timing_scopes") else []
+            require(len(timing_scopes) <= 1, f"column has multiple measured timing scopes: {key}")
+            require(isinstance(column.get("input_manifest_sha256"), str) and len(column["input_manifest_sha256"]) == 64, f"column input-manifest SHA missing: {key}")
+            pair_status(column)
+            require(int(column.get("precision_charge_rows", 0)) <= 1, f"column precision derivation charged more than once: {key}")
+            if row["method_family"] == "scaled9_decimal_int64_v1" and dtype_scope(str(column["dtype"])) == "float" and int(column["supported_valid_value_count"]) > 0:
+                require(int(column.get("precision_charge_rows", 0)) == 1 and column.get("precision_semantics"), f"scaled float column omits its one-time precision cost: {key}")
+        require(string_set(row, "profile_versions") == sorted({item for column in pair_columns for item in string_set(column, "profile_versions")}), f"dataset profile composition differs: {key}")
+        require(string_set(row, "configurations") == sorted({item for column in pair_columns for item in string_set(column, "configurations")}), f"dataset configuration composition differs: {key}")
+        require(
+            (string_set(row, "producer_cli_sha256") if row.get("producer_cli_sha256") else [])
+            == sorted({item for column in pair_columns for item in (string_set(column, "producer_cli_sha256") if column.get("producer_cli_sha256") else [])}),
+            f"dataset CLI composition differs: {key}",
+        )
+        scoped[key] = {"overall": scoped_summary(row, pair_columns, "overall")}
+        if row["support_state"] == "full_numeric":
+            require(scoped[key]["overall"]["support_sha256"] == row["eligible_support_sha256"], f"aggregate eligible support SHA differs: {key}")
+        require(scoped[key]["overall"]["typed_route_contract_sha256"] == row["typed_route_contract_sha256"], f"aggregate typed-route contract SHA differs: {key}")
+        for scope in ("integer", "float"):
+            if any(dtype_scope(str(column["dtype"])) == scope for column in pair_columns):
+                scoped[key][scope] = scoped_summary(row, pair_columns, scope)
+        if row["support_state"] == "full_numeric":
+            original = int(row["supported_original_numeric_bytes"])
+            compressed = int(row["measured_complete_frame_bytes"])
+            require(original > 0 and compressed > 0, f"full pair has empty bytes: {key}")
+            pooled = compressed / original
+            require(math.isclose(finite_number(row["secondary_pooled_compression_ratio"]), pooled, rel_tol=2e-12), f"pooled ratio differs: {key}")
+            finite_number(row["compression_ratio_column_arithmetic_mean"])
+            finite_number(row["compression_ns_per_valid_native_point_column_arithmetic_mean"])
+            finite_number(row["decompression_ns_per_valid_native_point_column_arithmetic_mean"])
+    require(dict(sorted(Counter(str(row["support_state"]) for row in rows).items())) == dict(sorted((receipt.get("dataset_method_support_counts") or {}).items())), "aggregate support counts differ from receipt")
+    return rows, scoped, receipt, {name: sums[name] for name in SOURCE_FILES if name != "SHA256SUMS"}
+
+
+def composite_route_label(route: dict[str, Any], field: str) -> str:
+    values = route[field]
+    require(values, f"typed route has no {field}")
+    if len(values) == 1:
+        return values[0]
+    value_field = "configuration" if field == "configurations" else "profile_version"
+    components = [f"{item['dtype']}={item[value_field]}" for item in route["routes"]]
+    return "typed-route[" + ";".join(components) + "]"
+
+
+def make_site_row(source: dict[str, Any], acceptance_sha: str) -> dict[str, Any]:
+    require(pair_status(source) == "numeric", "cannot construct numeric site row from a non-full pair")
+    dataset, method = str(source["dataset_id"]), str(source["method"])
+    binary = str(source["runtime_binary_sha256"])
+    route = source["typed_route"]
+    configuration = composite_route_label(route, "configurations")
+    profile_version = composite_route_label(route, "profile_versions")
+    original = int(source["supported_original_numeric_bytes"])
+    compressed = int(source["measured_complete_frame_bytes"])
+    points = int(source["supported_valid_value_count"])
+    compression_pp = finite_number(source["compression_ns_per_valid_native_point_column_arithmetic_mean"])
+    decompression_pp = finite_number(source["decompression_ns_per_valid_native_point_column_arithmetic_mean"])
+    return {
+        "schema": "compressionbenchmark-cpp135-main26-site-row-v1",
+        "dataset": dataset,
+        "scope": source["scope"],
+        "runtime": f"cpp-native192-main26-{binary[:8]}",
+        "comparison_profile": PROFILE,
+        "method": configuration,
+        "family": method,
+        "algorithm_variant": f"{configuration} [{binary[:8]}]",
+        "is_best_rate_in_family": True,
+        "original_size_bytes": original,
+        "compressed_size_bytes": compressed,
+        "point_count": points,
+        "compression_rate": compressed / original,
+        "compression_time_ns": compression_pp * points,
+        "decompression_time_ns": decompression_pp * points,
+        "compression_time_ns_per_point": compression_pp,
+        "decompression_time_ns_per_point": decompression_pp,
+        "timing_column_count": int(source["full_numeric_columns"]),
+        "timing_aggregation": "column_mean",
+        "eligible_dtype_scope": source["scope"],
+        "eligible_column_set_sha256": source["support_sha256"],
+        "eligible_column_set_status": "algorithm_independent_frozen_manifest_scope_cohort_sha256",
+        "measurement_status": "main26_complete_valid_support_builtin_bitexact_roundtrip",
+        "timing_profile_status": "timing_admitted_server192_main26_w1_r3_t1_column_mean_builtin_bitexact",
+        "execution_host": "192.168.99.20",
+        "binary_sha256": binary,
+        "producer_cli_sha256": source["producer_cli_sha256"][0] if len(source["producer_cli_sha256"]) == 1 else None,
+        "producer_cli_sha256_set": source["producer_cli_sha256"],
+        "profile_version": profile_version,
+        "typed_route": route["routes"],
+        "typed_route_configurations": route["configurations"],
+        "source_profile_composition": route["profile_versions"],
+        "typed_route_contract_sha256": source["typed_route_contract_sha256"],
+        "input_version": "final135-frozen-inputs-20261014-v1",
+        "acceptance_sha256": acceptance_sha,
+        "source_selection": source["selected_source"],
+        "selected_terminal_sha256": source["selected_terminal_sha256"],
+        "method_family": source["method_family"],
+        "byte_boundary": source["byte_boundary"],
+        "timing_contract": source["timing_contract"],
+        "column_arithmetic_mean_compression_rate": finite_number(source["compression_ratio_column_arithmetic_mean"]),
+        "all_missing_complete_frame_bytes": int(source["all_missing_complete_frame_bytes"]),
+    }
+
+
+def replace_latest_view(
+    old_sidecar: dict[str, Any], old_ui: dict[str, Any], new_ui: dict[str, Any],
+    source_rows: list[dict[str, Any]], scoped_rows: dict[tuple[str, str], dict[str, dict[str, Any]]],
+    additions: list[dict[str, Any]], acceptance_sha: str,
+    data_sha: str, ui_sha: str,
+) -> dict[str, Any]:
+    old_decoded, new_decoded = compact_rows(old_ui), compact_rows(new_ui)
+    old_count = len(old_decoded)
+    targets = {(str(row["dataset_id"]), str(row["method"])) for row in source_rows}
+    status_by_pair = {(str(row["dataset_id"]), str(row["method"])): pair_status(row) for row in source_rows}
+    require(len(targets) == EXPECTED_PAIR_COUNT, "latest-view target count differs")
+    retained = []
+    for item in old_sidecar["cpp"]["selected_rows"]:
+        decoded = old_decoded[item["raw_compact_index"]]
+        if (decoded["dataset"], item["canonical_family"]) not in targets:
+            retained.append(copy.deepcopy(item))
+
+    addition_by_scope = {(row["dataset"], row["family"], row["scope"]): index for index, row in enumerate(additions, start=old_count)}
+    require(len(addition_by_scope) == len(additions), "duplicate appended site row")
+    for scoped_pair, index in sorted(addition_by_scope.items()):
+        decoded = new_decoded[index]
+        pair = scoped_pair[:2]
+        require(decoded["dataset"] == pair[0] and decoded["family"] == pair[1] and decoded["scope"] == scoped_pair[2], f"appended compact row differs: {scoped_pair}")
+        retained.append({
+            "raw_compact_index": index,
+            "canonical_family": pair[1],
+            "source_family": pair[1],
+            "source_comparison_profile": PROFILE,
+            "source_runtime": decoded["runtime"],
+            "source_host": "192.168.99.20",
+            "authority": "cpp135_main26_server192_latest",
+            "pair_status": status_by_pair[pair],
+            "timing_admitted": True,
+            "measurement_status": decoded["measurement_status"],
+            "timing_profile_status": decoded["timing_profile_status"],
+        })
+
+    ledger = [copy.deepcopy(item) for item in old_sidecar["cpp"]["pair_ledger"] if (item["dataset"], item["canonical_family"]) not in targets]
+    source_by_pair = {(str(row["dataset_id"]), str(row["method"])): row for row in source_rows}
+    all_scopes = set(new_ui["record_tables"]["scopes"])
+    for pair in sorted(targets):
+        status = status_by_pair[pair]
+        selected = [index for (dataset, family, _), index in sorted(addition_by_scope.items()) if (dataset, family) == pair]
+        selected_scopes = sorted(scope for (dataset, family, scope) in addition_by_scope if (dataset, family) == pair)
+        if status == "numeric":
+            require("overall" in selected_scopes, f"full pair lacks Overall row: {pair}")
+        elif status == "partial_numeric":
+            require("overall" not in selected_scopes, f"partial pair exposes an Overall metric: {pair}")
+        else:
+            require(not selected, f"terminal pair exposes numeric scope: {pair}")
+        source = source_by_pair[pair]
+        ledger.append({
+            "dataset": pair[0],
+            "canonical_family": pair[1],
+            "decision": "select_latest_main26_dtype_scopes" if selected else "terminal_tombstone_latest_main26",
+            "status": status,
+            "source_comparison_profile": PROFILE,
+            "source_hosts": ["192.168.99.20"],
+            "selected_raw_indices": selected,
+            "selected_scopes": selected_scopes,
+            "missing_scopes_tombstoned": sorted(all_scopes - set(selected_scopes)),
+            "recency_rank": 60,
+            "authority": "cpp135_main26_server192_latest",
+            "reason": {
+                "numeric": "Completed server-192 column measurements support every valid value; exact Overall and available dtype-scope rows use pooled bytes and same-contract W1/R3/T1 column-mean timing.",
+                "partial_numeric": "Latest server-192 run supports only part of the valid workload; any completely supported dtype scope is selected, Overall is tombstoned, and no old numeric fallback is used.",
+                "unsupported": "Latest server-192 whole-column run has no supported valid-value column; older numeric rows are tombstoned.",
+                "not_applicable": "Latest server-192 whole-column run contains no valid numeric value for this method/dataset pair; older numeric rows are tombstoned.",
+            }[status],
+            "acceptance_sha256": acceptance_sha,
+            "source_selection": source["selected_source"],
+            "runtime_binary_sha256": source["runtime_binary_sha256"],
+            "scope_support_states": {scope: pair_status(summary) for scope, summary in sorted(scoped_rows[pair].items())},
+        })
+
+    retained.sort(key=lambda item: item["raw_compact_index"])
+    ledger.sort(key=lambda item: (item["dataset"], item["canonical_family"]))
+    by_index = {item["raw_compact_index"]: item for item in retained}
+    require(len(by_index) == len(retained), "duplicate selected compact index")
+    active = set(old_sidecar["cpp"]["active_native85_families"])
+    active_ledger = [item for item in ledger if item["canonical_family"] in active]
+    require(len(active_ledger) == 164 * 85, "active85 pair ledger changed size")
+    status_counts = Counter(item["status"] for item in active_ledger)
+    scope_dataset_counts: dict[str, int] = {}
+    scope_pair_counts: dict[str, int] = {}
+    for scope in sorted(all_scopes):
+        selected_for_scope = []
+        for item in retained:
+            decoded = new_decoded[item["raw_compact_index"]]
+            if decoded["scope"] == scope:
+                selected_for_scope.append((decoded["dataset"], item["canonical_family"]))
+        scope_dataset_counts[scope] = len({dataset for dataset, _ in selected_for_scope})
+        scope_pair_counts[scope] = len(set(selected_for_scope))
+    timing_indices = [item["raw_compact_index"] for item in retained if item["timing_admitted"]]
+
+    sidecar = copy.deepcopy(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": BASELINE_SHA256["data.json"],
+            "ui_data_sha256": BASELINE_SHA256["ui-data.json"],
+            "cpp_latest_view_sha256": BASELINE_SHA256["cpp-latest-view.json"],
+        },
+    }
+    sidecar["identity_contract"]["atomicity"] = "One newest authority wins per dataset and canonical C++ family. Main26 replaces all older selected scopes for its exact 135 x 26 pair universe; Overall requires whole-pair support while fully supported integer/float scopes remain independently visible."
+    sidecar["precedence"].append({
+        "rank": 60,
+        "authority": "cpp135_main26_server192_latest",
+        "scope": "135 measured datasets x 26 C++ families; exact Overall/integer/float support decisions from one column campaign",
+    })
+    sidecar["receipts"][PUBLIC_ACCEPTANCE] = {
+        "path": PUBLIC_ACCEPTANCE, "sha256": acceptance_sha,
+        "schema": "compressionbenchmark-cpp135-main26-site-acceptance-v1", "status": "accepted_completed_builtin_bitexact",
+    }
+    sidecar["cpp"]["selected_rows"] = retained
+    sidecar["cpp"]["pair_ledger"] = ledger
+    counts = sidecar["cpp"]["counts"]
+    counts.update({
+        "active_native85_pair_conclusions": len(active_ledger),
+        "active_native85_pair_status": dict(sorted(status_counts.items())),
+        "active_native85_numeric_pairs": status_counts["numeric"],
+        "active_native85_partial_numeric_pairs": status_counts["partial_numeric"],
+        "active_native85_measured_numeric_pairs": status_counts["numeric"] + status_counts["partial_numeric"],
+        "active_native85_terminal_tombstone_pairs": status_counts["not_applicable"] + status_counts["unsupported"],
+        "selected_compact_row_count": len(retained),
+        "timing_admitted_selected_row_count": len(timing_indices),
+        "scope_numeric_dataset_counts": scope_dataset_counts,
+        "scope_numeric_pair_counts": scope_pair_counts,
+        "main26_dataset_count": 135,
+        "main26_method_count": 26,
+        "main26_pair_count": EXPECTED_PAIR_COUNT,
+        "main26_pair_status": dict(sorted(Counter(status_by_pair.values()).items())),
+    })
+    sidecar["cpp"]["timing_subset"] = {
+        "contract": "Only row-local admitted timing is selected. Main26 numeric rows share the server-192 W1/R3/T1 whole-column contract and include built-in bit-exact decode checks; no independent fresh-process claim is made.",
+        "selected_raw_indices": timing_indices,
+        "selected_row_count": len(timing_indices),
+        "source_profile_counts": dict(sorted(Counter(new_decoded[item["raw_compact_index"]]["comparison_profile"] for item in retained if item["timing_admitted"]).items())),
+    }
+    sidecar["warnings"].append("Main26 publishes Overall only when every valid value is supported. A partial whole pair may retain an exact fully supported integer or float view; absent scopes are tombstoned and never fall back to old numbers.")
+    sidecar["warnings"].append("Main26 timing is W1/R3/T1 on server 192 with built-in bit-exact decode checks. It is not described as independent fresh-process verification.")
+    return sidecar
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--baseline", type=Path, required=True)
+    parser.add_argument("--aggregate", type=Path, required=True)
+    parser.add_argument("--expected-receipt-sha256", required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    baseline, aggregate, output = args.baseline.resolve(), args.aggregate.resolve(), args.output.resolve()
+    require(not output.exists(), "candidate exists; preserve it and choose a new output")
+    require(len(args.expected_receipt_sha256) == 64 and sha256(aggregate / "RECEIPT.json") == args.expected_receipt_sha256, "aggregate receipt SHA differs")
+    for name, digest in BASELINE_SHA256.items():
+        require((baseline / name).is_file() and sha256(baseline / name) == digest, f"immutable published baseline differs: {name}")
+    baseline_verified = baseline.parent / "BASELINE_VERIFIED.json"
+    baseline_receipt = read_json(baseline_verified) if baseline_verified.is_file() else {}
+    require(
+        baseline_receipt.get("status") == "verified"
+        and baseline_receipt.get("revision") == BASELINE_REVISION
+        and int(baseline_receipt.get("file_count", -1)) == 60,
+        "exact 60-file immutable baseline verification receipt missing",
+    )
+    datasets = measured_datasets(baseline)
+    source_rows, scoped_rows, aggregate_receipt, input_hashes = validate_inputs(aggregate, datasets)
+
+    shutil.copytree(baseline, output)
+    for source, public in SOURCE_FILES.items():
+        shutil.copy2(aggregate / source, output / public)
+    readme_path = output / "README.md"
+    readme = readme_path.read_text()
+    require(readme.count(README_OLD) == 1, "published README Main26 documentation anchor differs")
+    readme_path.write_text(readme.replace(README_OLD, README_NEW))
+
+    status_counts = Counter(pair_status(row) for row in source_rows)
+    scoped_status_counts = {
+        scope: dict(sorted(Counter(pair_status(by_scope[scope]) for by_scope in scoped_rows.values() if scope in by_scope).items()))
+        for scope in ("overall", "integer", "float")
+    }
+    acceptance = {
+        "schema": "compressionbenchmark-cpp135-main26-site-acceptance-v1",
+        "status": "accepted_completed_builtin_bitexact",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "scope": {"dataset_count": 135, "method_count": 26, "pair_count": EXPECTED_PAIR_COUNT, "method_ids": list(METHODS)},
+        "pair_status_counts": dict(sorted(status_counts.items())),
+        "dtype_scope_status_counts": scoped_status_counts,
+        "admission": {
+            "rate_bytes": "published only for a full_numeric Overall/integer/float scope as complete NGF1 frame bytes divided by original valid numeric bytes in that exact scope",
+            "timing": "published only for a full_numeric scope under one server-192 W1/R3/T1 column contract as equal-column arithmetic mean of ns per valid native-width point",
+            "lossless": "built-in bit-exact decode checks cover measured frames; no independent fresh-process verification claim",
+            "partial_and_terminal": "partial Overall never receives a numeric row; a completely supported dtype scope may remain numeric, while every absent scope has no old fallback",
+            "all_missing_frames": "all_missing_complete_frame_bytes is a subset of measured_complete_frame_bytes and is never added twice",
+        },
+        "aggregate_receipt": {"file": SOURCE_FILES["RECEIPT.json"], "sha256": sha256(aggregate / "RECEIPT.json"), "schema": aggregate_receipt.get("schema"), "status": aggregate_receipt.get("status")},
+        "inputs": {SOURCE_FILES[name]: {"sha256": digest, "bytes": (aggregate / name).stat().st_size} for name, digest in input_hashes.items()},
+    }
+    acceptance_path = output / PUBLIC_ACCEPTANCE
+    write_json(acceptance_path, acceptance)
+    acceptance_sha = sha256(acceptance_path)
+
+    old_data = read_json(baseline / "data.json")
+    old_ui = read_json(baseline / "ui-data.json")
+    old_sidecar = read_json(baseline / "cpp-latest-view.json")
+    old_rows_sha = canonical_sha(old_data["dataset_results"])
+    old_count = len(old_data["dataset_results"])
+    require(not any(row.get("comparison_profile") == PROFILE for row in old_data["dataset_results"]), "main26 profile already integrated")
+    additions = [
+        make_site_row(summary, acceptance_sha)
+        for pair in sorted(scoped_rows)
+        for scope, summary in sorted(scoped_rows[pair].items())
+        if pair_status(summary) == "numeric"
+    ]
+    additions.sort(key=lambda row: (row["dataset"], row["family"], row["scope"]))
+    data = copy.deepcopy(old_data)
+    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("main26_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)
+    exact_runtimes = sorted({row["runtime"] for row in additions})
+    data["benchmark"].setdefault("runtime_labels", {})[PROFILE] = "Native C++ · 192 · main26 whole-column W1/R3/T1"
+    data["benchmark"].setdefault("runtime_hosts", {})[PROFILE] = "192.168.99.20"
+    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": "cpp135-main26-site-import-v1", "comparison_profile": PROFILE,
+        "execution_host": "192.168.99.20", "dataset_count": 135, "method_count": 26,
+        "pair_count": EXPECTED_PAIR_COUNT, "numeric_row_count": len(additions),
+        "pair_status_counts": dict(sorted(status_counts.items())), "exact_runtimes": exact_runtimes,
+        "dtype_scope_status_counts": scoped_status_counts,
+        "aggregate_receipt": acceptance["aggregate_receipt"], "site_acceptance": {"file": PUBLIC_ACCEPTANCE, "sha256": acceptance_sha},
+        "timing_policy": "same server-192 W1/R3/T1 column contract; column arithmetic mean; full-valid-support Overall/integer/float scopes only",
+        "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["cpp135_main26"] = 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, ui_sha = sha256(output / "data.json"), sha256(output / "ui-data.json")
+    require(new_ui["source_data_sha256"] == data_sha and len(new_ui["compact_records"]) == len(data["dataset_results"]), "data/UI closure differs")
+
+    sidecar = replace_latest_view(old_sidecar, old_ui, new_ui, source_rows, scoped_rows, additions, acceptance_sha, data_sha, ui_sha)
+    write_json(output / "cpp-latest-view.json", sidecar)
+    sidecar_sha = sha256(output / "cpp-latest-view.json")
+    deterministic_gzip(output / "data.json", output / DATA_GZIP)
+    deterministic_gzip(output / "cpp-latest-view.json", output / SIDECAR_GZIP)
+    data_gzip_sha = sha256(output / DATA_GZIP)
+    sidecar_gzip_sha = sha256(output / SIDECAR_GZIP)
+
+    app_path = output / "app.js"
+    app = app_path.read_text()
+    require(app.count(BASELINE_SHA256["cpp-latest-view.json"]) == 1, "app sidecar SHA anchor differs")
+    require(app.count("20261015-float-scaling9-v1") == 2, "app payload cache anchors differ")
+    require(app.count("built_from_frozen_published_baseline_and_accepted_float_scaling9") == 1, "app sidecar status anchor differs")
+    app = app.replace(BASELINE_SHA256["cpp-latest-view.json"], sidecar_sha)
+    app = app.replace("20261015-float-scaling9-v1", VERSION)
+    app = app.replace("built_from_frozen_published_baseline_and_accepted_float_scaling9", SIDECAR_STATUS)
+    sidecar_constant = f"const CPP_LATEST_VIEW_SHA256='{sidecar_sha}';"
+    require(app.count(sidecar_constant) == 1, "app uncompressed sidecar SHA anchor differs")
+    app = app.replace(sidecar_constant, sidecar_constant + f"\nconst CPP_LATEST_VIEW_GZIP_SHA256='{sidecar_gzip_sha}';")
+    sha_helper = "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('');}"
+    gzip_helper = sha_helper + "\nasync function gunzipBuffer(buffer,label){if(typeof DecompressionStream!=='function')throw new Error(`${label} requires browser gzip decompression support.`);try{return await new Response(new Blob([buffer]).stream().pipeThrough(new DecompressionStream('gzip'))).arrayBuffer();}catch(error){throw new Error(`${label} could not be decompressed: ${error instanceof Error?error.message:String(error)}`);}}"
+    require(app.count(sha_helper) == 1, "app SHA helper anchor differs")
+    app = app.replace(sha_helper, gzip_helper)
+    old_fetch = f"fetch('./cpp-latest-view.json?v={VERSION}',{{cache:'no-cache'}})"
+    require(app.count(old_fetch) == 1, "app sidecar fetch anchor differs")
+    app = app.replace(old_fetch, f"fetch('./{SIDECAR_GZIP}?v={VERSION}',{{cache:'no-cache'}})")
+    old_buffers = "const [snapshotBuffer,sidecarBuffer]=await Promise.all([snapshotResponse.arrayBuffer(),sidecarResponse.arrayBuffer()]);\n  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.');"
+    new_buffers = "const [snapshotBuffer,sidecarGzipBuffer]=await Promise.all([snapshotResponse.arrayBuffer(),sidecarResponse.arrayBuffer()]);\n  const sidecarGzipSha=await sha256Hex(sidecarGzipBuffer);if(sidecarGzipSha!==CPP_LATEST_VIEW_GZIP_SHA256)throw new Error('The compressed C++ sidecar transport does not match the frozen release.');\n  const sidecarBuffer=await gunzipBuffer(sidecarGzipBuffer,'The combined C++ sidecar');\n  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.');"
+    require(app.count(old_buffers) == 1, "app sidecar buffer anchor differs")
+    app = app.replace(old_buffers, new_buffers)
+    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=20261015-float-scaling9-v1") == 1, "index app cache anchor differs")
+    index = index.replace("app.js?v=20261015-float-scaling9-v1", f"app.js?v={VERSION}")
+    require(index.count('href="data.json"') == 2, "index result-download anchors differ")
+    index = index.replace('href="data.json"', f'href="{DATA_GZIP}"')
+    index = index.replace("Result snapshot (JSON)", "Result snapshot (JSON.GZ)")
+    index_path.write_text(index)
+    require(sha256(output / "ranking.js") == BASELINE_SHA256["ranking.js"], "ranking.js changed")
+
+    manifest = read_json(output / "manifest.json")
+    manifest["data_file"] = DATA_GZIP
+    manifest["data_sha256"] = data_gzip_sha
+    manifest["data_uncompressed_sha256"] = data_sha
+    manifest["counts"] = coverage
+    manifest["measurement_runs"] = data["source"]["measurement_runs"]
+    manifest["cpp135_main26"] = run_summary
+    manifest["cpp135_main26"]["documentation"] = {"file": "README.md", "sha256": sha256(output / "README.md")}
+    manifest["cpp135_main26"]["publication_transport"] = {
+        "data": {"file": DATA_GZIP, "sha256": data_gzip_sha, "uncompressed_sha256": data_sha, "encoding": "gzip"},
+        "cpp_latest_view": {"file": SIDECAR_GZIP, "sha256": sidecar_gzip_sha, "uncompressed_sha256": sidecar_sha, "encoding": "gzip"},
+    }
+    manifest["data_transport"] = manifest["cpp135_main26"]["publication_transport"]["data"]
+    manifest["cpp_latest_view"] = {
+        "file": SIDECAR_GZIP, "sha256": sidecar_gzip_sha, "uncompressed_sha256": sidecar_sha,
+        "encoding": "gzip", "schema": sidecar["schema"], "status": sidecar["status"],
+    }
+    manifest["latest_page_inputs"] = {
+        "compact_data": {"file": "ui-data.json", "sha256": ui_sha},
+        "selection_sidecar": copy.deepcopy(manifest["cpp_latest_view"]),
+    }
+    manifest["historical_large_files"] = {
+        "data.json": {
+            "sha256": BASELINE_SHA256["data.json"],
+            "status": "preserved_historical_not_read_by_latest_page",
+        },
+        "cpp-latest-view.json": {
+            "sha256": BASELINE_SHA256["cpp-latest-view.json"],
+            "status": "preserved_historical_not_read_by_latest_page",
+        },
+    }
+    write_json(output / "manifest.json", manifest)
+
+    builder_name = Path(__file__).name
+    shutil.copy2(Path(__file__), output / builder_name)
+    changed = [
+        DATA_GZIP, "ui-data.json", SIDECAR_GZIP, "app.js", "index.html", "README.md", "manifest.json", GZIP_PACKAGER,
+        *SOURCE_FILES.values(), PUBLIC_ACCEPTANCE, builder_name,
+    ]
+    integration = {
+        "schema": "compressionbenchmark-cpp135-main26-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": 26, "pair_count": EXPECTED_PAIR_COUNT, "pair_status_counts": dict(sorted(status_counts.items()))},
+        "files": {name: {"bytes": (output / name).stat().st_size, "sha256": sha256(output / name)} for name in changed},
+        "publication_file_list": changed + [PUBLIC_INTEGRATION],
+        "semantic_checks": {
+            "all_3510_latest_pair_decisions_replaced": True,
+            "historical_rows_retained_byte_for_byte_in_canonical_order": True,
+            "numeric_rows_only_for_full_valid_support_within_exact_dtype_scope": True,
+            "partial_overall_never_published_but_full_dtype_scope_retained": True,
+            "partial_unsupported_not_applicable_numeric_fallback_count": 0,
+            "compressed_bytes_include_NA_frames_once": True,
+            "ranking_js_unchanged": True,
+            "readme_main26_scope_and_measurement_contract_updated": True,
+            "gzip_transport_decompresses_byte_exact_to_canonical_v2_payload": True,
+            "large_uncompressed_data_and_sidecar_excluded_from_publication_delta": True,
+            "app_javascript_syntax": "pass",
+            "data_ui_sidecar_hash_closure": True,
+        },
+        "page_checks_required_after_publication": [
+            "C++ Overall uses the latest main26 decision for all exact 135 x 26 pairs",
+            "full-support rows show server-192 provenance and one W1/R3/T1 timing contract",
+            "partial, unsupported and not-applicable pairs do not fall back to old numeric rows",
+            "CSV retains source host, binary/support identity, measurement status and timing status",
+        ],
+    }
+    integration_path = output / PUBLIC_INTEGRATION
+    write_json(integration_path, integration)
+    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"),
+        "data_gzip_sha256": data_gzip_sha, "cpp_latest_view_gzip_sha256": sidecar_gzip_sha,
+        "integration_sha256": sha256(integration_path),
+        "publication_files": integration["publication_file_list"],
+        "pair_status_counts": dict(sorted(status_counts.items())),
+        "numeric_rows_added": len(additions),
+    }
+    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-main26.json.gz

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

cpp135-main26-column-results.jsonl.gz

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

cpp135-main26-dataset-method-results.jsonl.gz

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

data-main26.json.gz

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

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=20261015-float-scaling9-v1" type="module"></script>
+  <script src="app.js?v=20261015-main26-gzip-v4" type="module"></script>
 </head>
 <body>
   <a class="skip-link" href="#content">Skip to results</a>
@@ -130,12 +130,12 @@
       <p>By default, each family selects the lowest-rate exact variant independently for each dataset only when all candidates for that dataset/family have one exact support set. This view can choose different binaries across datasets. Ambiguous support sets are omitted. Switch Method rows to Exact configuration to inspect fixed variants, source profiles, binaries, and support hashes.</p>
       <p>These are published measurements, not experiments executed inside this Space. A reported ratio alone does not establish lossless reconstruction; round-trip checks and hardware details are shown only when their evidence exists in the source snapshot. Timings without an exact admitted source/build/binary/boundary chain are unavailable to timing and composite rankings.</p>
       <h3>Download and provenance</h3>
-      <p><a href="data.json" download>Result snapshot (JSON)</a> · <a href="manifest.json" download>Source manifest (JSON)</a> · <a href="native86-coverage.json" download>Native86 coverage summary (JSON)</a> · <a href="native86-terminal-matrix.jsonl.gz" download>Historical 164-dataset terminal matrix (JSONL.GZ)</a> · <a href="native86-v9-current154-thin.jsonl.gz" download>Current 154-pair V9 evidence (JSONL.GZ)</a> · <a href="native86-recovery-reconciliation.json" download>Recovery reconciliation (JSON)</a></p>
+      <p><a href="data-main26.json.gz" download>Result snapshot (JSON.GZ)</a> · <a href="manifest.json" download>Source manifest (JSON)</a> · <a href="native86-coverage.json" download>Native86 coverage summary (JSON)</a> · <a href="native86-terminal-matrix.jsonl.gz" download>Historical 164-dataset terminal matrix (JSONL.GZ)</a> · <a href="native86-v9-current154-thin.jsonl.gz" download>Current 154-pair V9 evidence (JSONL.GZ)</a> · <a href="native86-recovery-reconciliation.json" download>Recovery reconciliation (JSON)</a></p>
       <div id="provenance"></div>
       <h3>Contribute a result</h3>
       <p>Run the project benchmark and provide the codec/configuration, input identity, compression and decompression measurements, execution environment, and round-trip validation evidence. Results can be updated from the source project using the snapshot exporter included in the Space repository.</p>
     </section>
-    <noscript><p class="error-message">Enable JavaScript to filter and sort this leaderboard. You can also download <a href="data.json">the results JSON</a>.</p></noscript>
+    <noscript><p class="error-message">Enable JavaScript to filter and sort this leaderboard. You can also download <a href="data-main26.json.gz">the results JSON</a>.</p></noscript>
     <footer><span>THULab · Time Series Compression Benchmark</span><span id="footer-snapshot"></span></footer>
   </main>
 </body>

manifest.json

@@ -33,7 +33,7 @@
   },
   "counts": {
     "catalog_dataset_count": 164,
-    "configuration_aggregate_row_count": 5782,
+    "configuration_aggregate_row_count": 5906,
     "corrected_five425": {
       "active_method_count": 85,
       "all_na_pair_count": 0,
@@ -66,8 +66,72 @@
       "special_support_review_pair_count": 8,
       "timing_admitted": false
     },
+    "cpp135_main26": {
+      "aggregate_receipt": {
+        "file": "CPP135_MAIN26_AGGREGATE_RECEIPT.json",
+        "schema": "cpp135-main26-aggregate-receipt-v2",
+        "sha256": "f098925d8bd0b5718b102a8b6921b1234ced3baec80e2faeb47f2edb71c2d337",
+        "status": "complete_summarized_builtin_lossless_not_independent_fresh_verification"
+      },
+      "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+      "dataset_count": 135,
+      "documentation": {
+        "file": "README.md",
+        "sha256": "c89a678703ff26d46f676a8bb807aff3da30c74961c21063ea277307c8e8af99"
+      },
+      "dtype_scope_status_counts": {
+        "float": {
+          "numeric": 1936,
+          "partial_numeric": 193,
+          "unsupported": 1355
+        },
+        "integer": {
+          "numeric": 572,
+          "unsupported": 572
+        },
+        "overall": {
+          "numeric": 1529,
+          "partial_numeric": 629,
+          "unsupported": 1352
+        }
+      },
+      "exact_runtimes": [
+        "cpp-native192-main26-0558378c",
+        "cpp-native192-main26-737e3b85"
+      ],
+      "execution_host": "192.168.99.20",
+      "method_count": 26,
+      "numeric_row_count": 4037,
+      "old_results_retained": true,
+      "pair_count": 3510,
+      "pair_status_counts": {
+        "numeric": 1529,
+        "partial_numeric": 629,
+        "unsupported": 1352
+      },
+      "publication_transport": {
+        "cpp_latest_view": {
+          "encoding": "gzip",
+          "file": "cpp-latest-view-main26.json.gz",
+          "sha256": "818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180",
+          "uncompressed_sha256": "f1aef2f23a0374e43ddde18d5ab2b29095ff344cf9ef4d591cd8037e55958a6e"
+        },
+        "data": {
+          "encoding": "gzip",
+          "file": "data-main26.json.gz",
+          "sha256": "7a00869fc545f1f2cb7a6c7bd2a6f72e12eddc7361edc68925d3b4bd04ac28a8",
+          "uncompressed_sha256": "e7f7a9f294c1a94aec0e8271c62308f499286cbe9bd2333a6fe685f0839cabb2"
+        }
+      },
+      "schema": "cpp135-main26-site-import-v1",
+      "site_acceptance": {
+        "file": "CPP135_MAIN26_SITE_ACCEPTANCE.json",
+        "sha256": "e99fdac1f870174c520a2a2fae643ca4259a33afb4feffd0e849a5a302ad91cd"
+      },
+      "timing_policy": "same server-192 W1/R3/T1 column contract; column arithmetic mean; full-valid-support Overall/integer/float scopes only"
+    },
     "dataset_count": 164,
-    "dataset_result_row_count": 94971,
+    "dataset_result_row_count": 99008,
     "excluded_datasets": [
       "Arade",
       "app_flow",
@@ -79,7 +143,7 @@
       "tiktok_trending_hashtags_music",
       "youtube_trending_2019_2020"
     ],
-    "family_best_aggregate_row_count": 1934,
+    "family_best_aggregate_row_count": 1997,
     "float_scaling9": {
       "acceptance": {
         "file": "FLOAT_SCALING9_SITE_ACCEPTANCE.json",
@@ -103,7 +167,7 @@
       "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": 932,
+    "method_configuration_count": 982,
     "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,
@@ -402,8 +466,8 @@
     "native86_unresolved_problem_pair_count": 0,
     "native86_v9_recovered_pair_count": 154,
     "paper_leaderboard_row_count": 0,
-    "runtime_configuration_count": 1573,
-    "runtime_count": 13,
+    "runtime_configuration_count": 1630,
+    "runtime_count": 14,
     "runtimes": [
       "cpp",
       "cpp-native166-corrected-five-20261012-v1",
@@ -415,6 +479,7 @@
       "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-main26-whole-column-20261015-v1",
       "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3",
       "java",
       "python"
@@ -426,14 +491,87 @@
     "timing_dataset_aggregate_result_count": 0,
     "timing_unavailable_dataset_result_count": 67677
   },
+  "cpp135_main26": {
+    "aggregate_receipt": {
+      "file": "CPP135_MAIN26_AGGREGATE_RECEIPT.json",
+      "schema": "cpp135-main26-aggregate-receipt-v2",
+      "sha256": "f098925d8bd0b5718b102a8b6921b1234ced3baec80e2faeb47f2edb71c2d337",
+      "status": "complete_summarized_builtin_lossless_not_independent_fresh_verification"
+    },
+    "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+    "dataset_count": 135,
+    "documentation": {
+      "file": "README.md",
+      "sha256": "c89a678703ff26d46f676a8bb807aff3da30c74961c21063ea277307c8e8af99"
+    },
+    "dtype_scope_status_counts": {
+      "float": {
+        "numeric": 1936,
+        "partial_numeric": 193,
+        "unsupported": 1355
+      },
+      "integer": {
+        "numeric": 572,
+        "unsupported": 572
+      },
+      "overall": {
+        "numeric": 1529,
+        "partial_numeric": 629,
+        "unsupported": 1352
+      }
+    },
+    "exact_runtimes": [
+      "cpp-native192-main26-0558378c",
+      "cpp-native192-main26-737e3b85"
+    ],
+    "execution_host": "192.168.99.20",
+    "method_count": 26,
+    "numeric_row_count": 4037,
+    "old_results_retained": true,
+    "pair_count": 3510,
+    "pair_status_counts": {
+      "numeric": 1529,
+      "partial_numeric": 629,
+      "unsupported": 1352
+    },
+    "publication_transport": {
+      "cpp_latest_view": {
+        "encoding": "gzip",
+        "file": "cpp-latest-view-main26.json.gz",
+        "sha256": "818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180",
+        "uncompressed_sha256": "f1aef2f23a0374e43ddde18d5ab2b29095ff344cf9ef4d591cd8037e55958a6e"
+      },
+      "data": {
+        "encoding": "gzip",
+        "file": "data-main26.json.gz",
+        "sha256": "7a00869fc545f1f2cb7a6c7bd2a6f72e12eddc7361edc68925d3b4bd04ac28a8",
+        "uncompressed_sha256": "e7f7a9f294c1a94aec0e8271c62308f499286cbe9bd2333a6fe685f0839cabb2"
+      }
+    },
+    "schema": "cpp135-main26-site-import-v1",
+    "site_acceptance": {
+      "file": "CPP135_MAIN26_SITE_ACCEPTANCE.json",
+      "sha256": "e99fdac1f870174c520a2a2fae643ca4259a33afb4feffd0e849a5a302ad91cd"
+    },
+    "timing_policy": "same server-192 W1/R3/T1 column contract; column arithmetic mean; full-valid-support Overall/integer/float scopes only"
+  },
   "cpp_latest_view": {
-    "file": "cpp-latest-view.json",
+    "encoding": "gzip",
+    "file": "cpp-latest-view-main26.json.gz",
     "schema": "compressionbenchmark-cpp-latest-view-v1",
-    "sha256": "564b8f7760a6336e93bd0d69601e74ada9819b361dc2464d768689af0d287cbd",
-    "status": "built_from_frozen_published_baseline_and_accepted_float_scaling9"
+    "sha256": "818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180",
+    "status": "built_from_verified_live_float9_baseline_and_completed_main26",
+    "uncompressed_sha256": "f1aef2f23a0374e43ddde18d5ab2b29095ff344cf9ef4d591cd8037e55958a6e"
+  },
+  "data_file": "data-main26.json.gz",
+  "data_sha256": "7a00869fc545f1f2cb7a6c7bd2a6f72e12eddc7361edc68925d3b4bd04ac28a8",
+  "data_transport": {
+    "encoding": "gzip",
+    "file": "data-main26.json.gz",
+    "sha256": "7a00869fc545f1f2cb7a6c7bd2a6f72e12eddc7361edc68925d3b4bd04ac28a8",
+    "uncompressed_sha256": "e7f7a9f294c1a94aec0e8271c62308f499286cbe9bd2333a6fe685f0839cabb2"
   },
-  "data_file": "data.json",
-  "data_sha256": "3c66633b2d58b126edfad8afe173caf1f53fbcdb6f7b205c3d51b42dfc75a241",
+  "data_uncompressed_sha256": "e7f7a9f294c1a94aec0e8271c62308f499286cbe9bd2333a6fe685f0839cabb2",
   "dataset_catalog_sha256": "47869c8078e8c864810d4f961fa5879e120943bb3f371b39f0adc74f3de2ee2d",
   "excluded_content": [
     "raw datasets",
@@ -465,6 +603,30 @@
     "schema": "float-scaling9-site-import-v1",
     "timing_policy": "server192 float and pure-float overall only; mixed overall timing null; never enters server166-only figures"
   },
+  "historical_large_files": {
+    "cpp-latest-view.json": {
+      "sha256": "564b8f7760a6336e93bd0d69601e74ada9819b361dc2464d768689af0d287cbd",
+      "status": "preserved_historical_not_read_by_latest_page"
+    },
+    "data.json": {
+      "sha256": "3c66633b2d58b126edfad8afe173caf1f53fbcdb6f7b205c3d51b42dfc75a241",
+      "status": "preserved_historical_not_read_by_latest_page"
+    }
+  },
+  "latest_page_inputs": {
+    "compact_data": {
+      "file": "ui-data.json",
+      "sha256": "841b15cbef0c346b43d72ab3c9530065abe4d24c45aef64d5e75d8ec49996f8f"
+    },
+    "selection_sidecar": {
+      "encoding": "gzip",
+      "file": "cpp-latest-view-main26.json.gz",
+      "schema": "compressionbenchmark-cpp-latest-view-v1",
+      "sha256": "818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180",
+      "status": "built_from_verified_live_float9_baseline_and_completed_main26",
+      "uncompressed_sha256": "f1aef2f23a0374e43ddde18d5ab2b29095ff344cf9ef4d591cd8037e55958a6e"
+    }
+  },
   "measurement_runs": [
     {
       "decode_boundary": "DBF header parse, integer-body decode, and inverse scaling or IEEE-word reconstruction",
@@ -1076,6 +1238,52 @@
       "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"
+    },
+    {
+      "aggregate_receipt": {
+        "file": "CPP135_MAIN26_AGGREGATE_RECEIPT.json",
+        "schema": "cpp135-main26-aggregate-receipt-v2",
+        "sha256": "f098925d8bd0b5718b102a8b6921b1234ced3baec80e2faeb47f2edb71c2d337",
+        "status": "complete_summarized_builtin_lossless_not_independent_fresh_verification"
+      },
+      "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+      "dataset_count": 135,
+      "dtype_scope_status_counts": {
+        "float": {
+          "numeric": 1936,
+          "partial_numeric": 193,
+          "unsupported": 1355
+        },
+        "integer": {
+          "numeric": 572,
+          "unsupported": 572
+        },
+        "overall": {
+          "numeric": 1529,
+          "partial_numeric": 629,
+          "unsupported": 1352
+        }
+      },
+      "exact_runtimes": [
+        "cpp-native192-main26-0558378c",
+        "cpp-native192-main26-737e3b85"
+      ],
+      "execution_host": "192.168.99.20",
+      "method_count": 26,
+      "numeric_row_count": 4037,
+      "old_results_retained": true,
+      "pair_count": 3510,
+      "pair_status_counts": {
+        "numeric": 1529,
+        "partial_numeric": 629,
+        "unsupported": 1352
+      },
+      "schema": "cpp135-main26-site-import-v1",
+      "site_acceptance": {
+        "file": "CPP135_MAIN26_SITE_ACCEPTANCE.json",
+        "sha256": "e99fdac1f870174c520a2a2fae643ca4259a33afb4feffd0e849a5a302ad91cd"
+      },
+      "timing_policy": "same server-192 W1/R3/T1 column contract; column arithmetic mean; full-valid-support Overall/integer/float scopes only"
     }
   ],
   "native86_imports": {