Complete 135-dataset results for Crush, Density, Gipfeli, LZO2A and Lzlib

Publish 675 completed server-192 dataset-method results with original-dtype bit-exact decoding checks. Preserve earlier results. The final WiDS / LZG measurement remains pending.

.gitattributes

@@ -39,3 +39,4 @@ dbp-audit.json filter=lfs diff=lfs merge=lfs -text
 cpp-latest-view.json filter=lfs diff=lfs merge=lfs -text
 ui-data.json filter=lfs diff=lfs merge=lfs -text
 data-main26.json.br filter=lfs diff=lfs merge=lfs -text
+data-remaining6-completed5.json.br filter=lfs diff=lfs merge=lfs -text

REMAINING6_COMPLETED5_ACCEPTANCE.json

@@ -0,0 +1,129 @@
+{
+  "created_at": "2026-10-16T03:24:43.059681+00:00",
+  "historical_variants_preserved": true,
+  "lossless": "producer compared the complete original Block after every warmup and measured decode",
+  "methods": {
+    "Crush": {
+      "configurations": [
+        "level0_single_thread+zero_padded_workspace+encode_decode_admission+tagged_raw_fallback"
+      ],
+      "dataset_count": 135,
+      "profile_versions": [
+        "baseline86-fixed-profiles-20260919-v3"
+      ],
+      "runtime_binary_sha256_set": [
+        "2d137271d314fa3991fe85c4a4f9baf55f346c4f9b5872cc299b8a89cc39163e",
+        "c67a1ed796f6f2d762fdd275f70f6389cb672bf52e7729c310353e3d918c766a"
+      ],
+      "source_selection_set": [
+        "timing383_attempt3_server192",
+        "timing383_repair16_fix2_server192",
+        "timing_remaining6_uniform192_fix2_server192"
+      ]
+    },
+    "Density": {
+      "configurations": [
+        "lion_default_single_thread_tagged_raw_fallback"
+      ],
+      "dataset_count": 135,
+      "profile_versions": [
+        "baseline86-fixed-profiles-20260919-v3"
+      ],
+      "runtime_binary_sha256_set": [
+        "2d137271d314fa3991fe85c4a4f9baf55f346c4f9b5872cc299b8a89cc39163e",
+        "c67a1ed796f6f2d762fdd275f70f6389cb672bf52e7729c310353e3d918c766a"
+      ],
+      "source_selection_set": [
+        "timing383_attempt3_server192",
+        "timing_remaining6_uniform192_fix2_server192"
+      ]
+    },
+    "Gipfeli": {
+      "configurations": [
+        "string_api_default_single_thread+encode_decode_admission+tagged_raw_fallback"
+      ],
+      "dataset_count": 135,
+      "profile_versions": [
+        "baseline86-fixed-profiles-20260919-v3"
+      ],
+      "runtime_binary_sha256_set": [
+        "2d137271d314fa3991fe85c4a4f9baf55f346c4f9b5872cc299b8a89cc39163e",
+        "c67a1ed796f6f2d762fdd275f70f6389cb672bf52e7729c310353e3d918c766a"
+      ],
+      "source_selection_set": [
+        "timing383_attempt3_server192",
+        "timing383_repair16_fix2_server192",
+        "timing_remaining6_uniform192_fix2_server192"
+      ]
+    },
+    "LZO2A": {
+      "configurations": [
+        "lzo2a_999_single_thread+control_bit_worst_case_bound+encode_decode_admission+tagged_raw_fallback"
+      ],
+      "dataset_count": 135,
+      "profile_versions": [
+        "baseline86-fixed-profiles-20260919-v3"
+      ],
+      "runtime_binary_sha256_set": [
+        "2d137271d314fa3991fe85c4a4f9baf55f346c4f9b5872cc299b8a89cc39163e",
+        "c67a1ed796f6f2d762fdd275f70f6389cb672bf52e7729c310353e3d918c766a"
+      ],
+      "source_selection_set": [
+        "timing383_attempt3_server192",
+        "timing383_repair16_fix2_server192",
+        "timing_remaining6_uniform192_fix2_server192"
+      ]
+    },
+    "Lzlib": {
+      "configurations": [
+        "level6_dict8MiB_match36_single_thread_tagged_raw_fallback"
+      ],
+      "dataset_count": 135,
+      "profile_versions": [
+        "baseline86-fixed-profiles-20260919-v3"
+      ],
+      "runtime_binary_sha256_set": [
+        "c67a1ed796f6f2d762fdd275f70f6389cb672bf52e7729c310353e3d918c766a"
+      ],
+      "source_selection_set": [
+        "timing383_repair16_fix2_server192",
+        "timing_remaining6_uniform192_fix2_server192"
+      ]
+    }
+  },
+  "overlay_receipt_sha256": "70a8782c0324ec29f48c478ba1aa35c922b84194335af48a912911435895532e",
+  "parent_revision": "a667e581961f786940c9e1c59172e6057db72600",
+  "public_evidence": {
+    "REMAINING6_COMPLETED5_OVERLAY_RECEIPT.json": {
+      "bytes": 1001,
+      "sha256": "70a8782c0324ec29f48c478ba1aa35c922b84194335af48a912911435895532e"
+    },
+    "REMAINING6_COMPLETED5_SOURCE_BINDINGS.json": {
+      "bytes": 1246,
+      "sha256": "7a63cd921cee63e53de4a74f21c38c154ff3073eeb81d42a12be79241305ba2b"
+    },
+    "remaining6-completed5-dataset-method-overlay.jsonl.gz": {
+      "bytes": 140763,
+      "sha256": "9ec315718182471c54eab9af11d9ddeac66fb08f23fb136ffd727816f495d6b8"
+    }
+  },
+  "schema": "compressionbenchmark-cpp135-remaining6-acceptance-v1",
+  "scope": {
+    "column_count": 3519,
+    "column_method_row_count": 17595,
+    "dataset_count": 135,
+    "method_count": 5,
+    "pair_count": 675
+  },
+  "scope_name": "completed5",
+  "source_bindings_sha256": "7a63cd921cee63e53de4a74f21c38c154ff3073eeb81d42a12be79241305ba2b",
+  "status": "accepted_completed_builtin_bitexact",
+  "timing": {
+    "aggregation": "equal-column mean of median(aligned block sums)/valid native points",
+    "comparison_profile": "cpp-native192-remaining-six135-whole-column-20261016-v1",
+    "cross_host_mixing": false,
+    "host": "192.168.99.20",
+    "schedule": "one warmup; three encode measurements; then three decode measurements",
+    "threads": 1
+  }
+}

REMAINING6_COMPLETED5_CANDIDATE_QA.json

@@ -0,0 +1,68 @@
+{
+  "pair_ledger_count": 13975,
+  "parent_revision": "a667e581961f786940c9e1c59172e6057db72600",
+  "ranking_unchanged": true,
+  "schema": "cpp135-remaining6-incremental-candidate-qa-v1",
+  "scope_name": "completed5",
+  "selected_row_count": 32631,
+  "status": "passed",
+  "target_methods": [
+    {
+      "family": "Crush",
+      "hosts": [
+        "192.168.99.20"
+      ],
+      "profiles": [
+        "cpp-native192-remaining-six135-whole-column-20261016-v1"
+      ],
+      "rate_coverage": 135,
+      "timing_coverage": 135
+    },
+    {
+      "family": "Density",
+      "hosts": [
+        "192.168.99.20"
+      ],
+      "profiles": [
+        "cpp-native192-remaining-six135-whole-column-20261016-v1"
+      ],
+      "rate_coverage": 135,
+      "timing_coverage": 135
+    },
+    {
+      "family": "Gipfeli",
+      "hosts": [
+        "192.168.99.20"
+      ],
+      "profiles": [
+        "cpp-native192-remaining-six135-whole-column-20261016-v1"
+      ],
+      "rate_coverage": 135,
+      "timing_coverage": 135
+    },
+    {
+      "family": "LZO2A",
+      "hosts": [
+        "192.168.99.20"
+      ],
+      "profiles": [
+        "cpp-native192-remaining-six135-whole-column-20261016-v1"
+      ],
+      "rate_coverage": 135,
+      "timing_coverage": 135
+    },
+    {
+      "family": "Lzlib",
+      "hosts": [
+        "192.168.99.20"
+      ],
+      "profiles": [
+        "cpp-native192-remaining-six135-whole-column-20261016-v1"
+      ],
+      "rate_coverage": 135,
+      "timing_coverage": 135
+    }
+  ],
+  "unaffected_pair_ledger_preserved": true,
+  "unaffected_selected_rows_preserved": true
+}

REMAINING6_COMPLETED5_INCREMENTAL_INTEGRATION.json

@@ -0,0 +1,112 @@
+{
+  "authority": "cpp135_remaining_six_server192_latest",
+  "canonical_snapshot": {
+    "base_data_sha256": "5c20e191e146d02408f4d7fc41224e8e72b81bd18bf862f3dbda1708d44706f8",
+    "base_revision": "a667e581961f786940c9e1c59172e6057db72600",
+    "derived_data_sha256": "a0e8b3c6207e627fe9c863a968af52257750f6c33becd231201803bc80f1c184",
+    "derived_sidecar_sha256": "29499dcee2681cd97ec27326dc3fcb321c77b1a165d9f829f5e27a6d7d2ebd9b",
+    "derived_ui_sha256": "5ca409427984e14e3cab4b55d8dc7ad55cf4def9119871c48908ea869adc7576"
+  },
+  "created_at": "2026-10-16T03:24:58.287605+00:00",
+  "final_dataset_result_count": 106739,
+  "historical_dataset_result_count": 105174,
+  "historical_dataset_results_canonical_sha256": "483bd1d09e70ee51c13bae3dce7f1e11d1b54af0bd6604b7a478d7d04154a276",
+  "new_dataset_result_count": 1565,
+  "overlay": {
+    "column_results_sha256": "ed3ce96c07235854ab08c393f8bea2745fec4e887e57bd34ee92cf03aeacb70b",
+    "dataset_method_results_sha256": "9ec315718182471c54eab9af11d9ddeac66fb08f23fb136ffd727816f495d6b8",
+    "receipt_sha256": "70a8782c0324ec29f48c478ba1aa35c922b84194335af48a912911435895532e",
+    "source_bindings_sha256": "7a63cd921cee63e53de4a74f21c38c154ff3073eeb81d42a12be79241305ba2b"
+  },
+  "parent_revision": "a667e581961f786940c9e1c59172e6057db72600",
+  "publication_file_list": [
+    "app.js",
+    "index.html",
+    "manifest.json",
+    "ui-data-remaining6-completed5.json.gz",
+    "cpp-latest-view-remaining6-completed5.json.gz",
+    "remaining6-completed5-dataset-method-overlay.jsonl.gz",
+    "REMAINING6_COMPLETED5_OVERLAY_RECEIPT.json",
+    "REMAINING6_COMPLETED5_SOURCE_BINDINGS.json",
+    "REMAINING6_COMPLETED5_ACCEPTANCE.json",
+    "REMAINING6_COMPLETED5_CANDIDATE_QA.json",
+    "build_remaining6_incremental_site.py",
+    "REMAINING6_COMPLETED5_INCREMENTAL_INTEGRATION.json"
+  ],
+  "publication_files_excluding_this_receipt": {
+    "REMAINING6_COMPLETED5_ACCEPTANCE.json": {
+      "bytes": 4655,
+      "sha256": "5940179bc7fa1b43c0db86efb063f8e7c40b6b5ddd6ba07bcfc9893f990acae3"
+    },
+    "REMAINING6_COMPLETED5_CANDIDATE_QA.json": {
+      "bytes": 1591,
+      "sha256": "8ef90c549de5a28ff56e969dc29e5e9d7ff1953556222de4b0fa8ad7f8355ad4"
+    },
+    "REMAINING6_COMPLETED5_OVERLAY_RECEIPT.json": {
+      "bytes": 1001,
+      "sha256": "70a8782c0324ec29f48c478ba1aa35c922b84194335af48a912911435895532e"
+    },
+    "REMAINING6_COMPLETED5_SOURCE_BINDINGS.json": {
+      "bytes": 1246,
+      "sha256": "7a63cd921cee63e53de4a74f21c38c154ff3073eeb81d42a12be79241305ba2b"
+    },
+    "app.js": {
+      "bytes": 70219,
+      "sha256": "7b47ff8a3b7e1c823e82568946ca94d36a1441398d444863c37b120e676ff632"
+    },
+    "build_remaining6_incremental_site.py": {
+      "bytes": 31891,
+      "sha256": "358404633f9652ab2744c64e63b2c4679d8c03674cf30a9faf4c9809f557c8e1"
+    },
+    "cpp-latest-view-remaining6-completed5.json.gz": {
+      "bytes": 1689596,
+      "sha256": "dc03363557cabbc83b2e2020d4c5972590fd27f81edde08dc2ac62b4a37238e6"
+    },
+    "index.html": {
+      "bytes": 17946,
+      "sha256": "a319cb6aec162890c12e3cd7df046ef28007da13421acb663a7daaea0948db3e"
+    },
+    "manifest.json": {
+      "bytes": 120145,
+      "sha256": "995a7aa9212eef449279f9f3bdb126ff0c7a28be3aaed1ccf4c4601b67654f59"
+    },
+    "remaining6-completed5-dataset-method-overlay.jsonl.gz": {
+      "bytes": 140763,
+      "sha256": "9ec315718182471c54eab9af11d9ddeac66fb08f23fb136ffd727816f495d6b8"
+    },
+    "ui-data-remaining6-completed5.json.gz": {
+      "bytes": 2377658,
+      "sha256": "ed571b4053ce4289be5bd4d002e10289c23497d04e3535774bb6aff4a6c43426"
+    }
+  },
+  "publication_total_bytes_excluding_this_receipt": 4456711,
+  "schema": "compressionbenchmark-cpp135-remaining6-incremental-integration-v1",
+  "scope": {
+    "column_count": 3519,
+    "column_method_row_count": 17595,
+    "methods": [
+      "Crush",
+      "Density",
+      "Gipfeli",
+      "LZO2A",
+      "Lzlib"
+    ],
+    "numeric_scope_rows": 1565,
+    "pair_count": 675
+  },
+  "scope_name": "completed5",
+  "semantic_checks": {
+    "base_plus_overlay_hash_closure": true,
+    "built_in_exact_block_bound": true,
+    "historical_rows_retained": true,
+    "live_ui_sidecar_hash_closure": true,
+    "only_target_pairs_replaced": true,
+    "ranking_unchanged": true,
+    "same_host_w1_r3_t1": true,
+    "target_methods_each_cover_135_datasets": true,
+    "target_methods_no_mixed_timing_identity": true,
+    "unaffected_pair_ledger_preserved": true,
+    "unaffected_selected_rows_preserved": true
+  },
+  "status": "passed_not_published"
+}

REMAINING6_COMPLETED5_OVERLAY_RECEIPT.json

@@ -0,0 +1,37 @@
+{
+  "column_count": 3519,
+  "column_method_count": 17595,
+  "created_epoch_ns": 1792120862700414201,
+  "dataset_count": 135,
+  "dataset_method_count": 675,
+  "dataset_method_support_counts": {
+    "full_numeric": 675
+  },
+  "excluded_pending_methods": [
+    "LZG"
+  ],
+  "files": {
+    "COLUMN_RESULTS.jsonl.gz": {
+      "bytes": 4486956,
+      "sha256": "ed3ce96c07235854ab08c393f8bea2745fec4e887e57bd34ee92cf03aeacb70b"
+    },
+    "DATASET_METHOD_RESULTS.jsonl.gz": {
+      "bytes": 140763,
+      "sha256": "9ec315718182471c54eab9af11d9ddeac66fb08f23fb136ffd727816f495d6b8"
+    },
+    "SOURCE_BINDINGS.json": {
+      "bytes": 1246,
+      "sha256": "7a63cd921cee63e53de4a74f21c38c154ff3073eeb81d42a12be79241305ba2b"
+    }
+  },
+  "method_counts": {
+    "Crush": 135,
+    "Density": 135,
+    "Gipfeli": 135,
+    "LZO2A": 135,
+    "Lzlib": 135
+  },
+  "schema": "cpp135-remaining6-completed5-overlay-receipt-v1",
+  "source_host": "192.168.99.20",
+  "status": "complete_combined_compacts_not_published"
+}

REMAINING6_COMPLETED5_SOURCE_BINDINGS.json

@@ -0,0 +1,31 @@
+{
+  "column_method_count": 17595,
+  "dataset_method_count": 675,
+  "excluded_pending_methods": [
+    "LZG"
+  ],
+  "inputs": {
+    "crush": {
+      "path": "/data/root/web_compression/cpp135_lossless_completion_20261015_v1/timing383/timing_remaining6_uniform192_v1/aggregate_completed5_v1/crush_output",
+      "receipt_sha256": "c3884511fc9bb9d800b3474301e9b4627c22dccebcaf153fefdfd00ec893d49e",
+      "source_bindings_sha256": "180686313de461860952a083f780f904b23757c10360feb35c91493518c9dbfc"
+    },
+    "fast4": {
+      "path": "/data/root/web_compression/cpp135_lossless_completion_20261015_v1/timing383/timing_remaining6_uniform192_v1/aggregate_v1/fast4_output",
+      "receipt_sha256": "7fe07858e08e2d194be1b1c60a5d49c3946de2692e9fe495e0860a67f76ec3ff",
+      "source_bindings_sha256": "c9dcc899ef3f874343af287ff99b247ef80079bf2b4cc5c8648c73dd7027f3ce"
+    }
+  },
+  "method_counts": {
+    "Crush": 135,
+    "Density": 135,
+    "Gipfeli": 135,
+    "LZO2A": 135,
+    "Lzlib": 135
+  },
+  "old_results_preserved": true,
+  "raw_result_policy": "no raw JSONL reread; compact union only",
+  "schema": "cpp135-remaining6-completed5-source-bindings-v1",
+  "source_host": "192.168.99.20",
+  "status": "combined_from_frozen_fast4_and_crush_compacts"
+}

REMAINING6_COMPLETED5_TRANSPORT_V3.json

@@ -0,0 +1,124 @@
+{
+  "base_plus_patch": {
+    "base_revision": "a667e581961f786940c9e1c59172e6057db72600",
+    "sidecar_patch": {
+      "file": "cpp-latest-view-remaining6-completed5-patch.json.gz",
+      "sha256": "c54b1ad640406637120e3b273002f35e125f4390dc393f3ac21aff29c0ec7f63",
+      "uncompressed_sha256": "8e98c21986c4a7ca79b6af19d92fcb923d26ad314e2857d900f9906fc13463f6"
+    },
+    "ui_patch": {
+      "file": "ui-data-remaining6-completed5-patch.json.gz",
+      "sha256": "5169074c3097d131ffbc550ac1466e719e65f8e7ae630dedbec352b5ce16bca3",
+      "uncompressed_sha256": "66dbd2505522c16bd996bf4dabfc7afdd64fadf15e9307bf16230960ab1591e5"
+    }
+  },
+  "checks": {
+    "UI_patch_reconstructs_completed5": true,
+    "base_assets_reused_by_sha": true,
+    "full_download_is_latest_logical_snapshot": true,
+    "historical_results_preserved": true,
+    "old_online_files_not_deleted": true,
+    "selection_patch_reconstructs_completed5": true
+  },
+  "full_snapshot": {
+    "encoding": "br",
+    "file": "data-remaining6-completed5.json.br",
+    "quality": 10,
+    "roundtrip_byte_identical": true,
+    "sha256": "892caa7075806b231913c7414c5774e26458ca9b7acf784f27a7eefac77cae8e",
+    "uncompressed_sha256": "a0e8b3c6207e627fe9c863a968af52257750f6c33becd231201803bc80f1c184"
+  },
+  "parent_revision": "a667e581961f786940c9e1c59172e6057db72600",
+  "publication_file_list": [
+    "data-remaining6-completed5.json.br",
+    "ui-data-remaining6-completed5-patch.json.gz",
+    "cpp-latest-view-remaining6-completed5-patch.json.gz",
+    "app.js",
+    "index.html",
+    "manifest.json",
+    "remaining6-completed5-dataset-method-overlay.jsonl.gz",
+    "REMAINING6_COMPLETED5_OVERLAY_RECEIPT.json",
+    "REMAINING6_COMPLETED5_SOURCE_BINDINGS.json",
+    "REMAINING6_COMPLETED5_ACCEPTANCE.json",
+    "REMAINING6_COMPLETED5_CANDIDATE_QA.json",
+    "build_remaining6_incremental_site.py",
+    "REMAINING6_COMPLETED5_INCREMENTAL_INTEGRATION.json",
+    "build_completed5_storage_transport_v3.py",
+    "REMAINING6_COMPLETED5_TRANSPORT_V3.json"
+  ],
+  "publication_files_excluding_this_receipt": {
+    "REMAINING6_COMPLETED5_ACCEPTANCE.json": {
+      "bytes": 4655,
+      "sha256": "5940179bc7fa1b43c0db86efb063f8e7c40b6b5ddd6ba07bcfc9893f990acae3"
+    },
+    "REMAINING6_COMPLETED5_CANDIDATE_QA.json": {
+      "bytes": 1591,
+      "sha256": "8ef90c549de5a28ff56e969dc29e5e9d7ff1953556222de4b0fa8ad7f8355ad4"
+    },
+    "REMAINING6_COMPLETED5_INCREMENTAL_INTEGRATION.json": {
+      "bytes": 4530,
+      "sha256": "64512393d050a1d2766bc848b4f885b22100bdf8ce8877f20d5a9d20ab7bf23f"
+    },
+    "REMAINING6_COMPLETED5_OVERLAY_RECEIPT.json": {
+      "bytes": 1001,
+      "sha256": "70a8782c0324ec29f48c478ba1aa35c922b84194335af48a912911435895532e"
+    },
+    "REMAINING6_COMPLETED5_SOURCE_BINDINGS.json": {
+      "bytes": 1246,
+      "sha256": "7a63cd921cee63e53de4a74f21c38c154ff3073eeb81d42a12be79241305ba2b"
+    },
+    "app.js": {
+      "bytes": 73030,
+      "sha256": "c6a696f653bed995c11500ba42eee1d5646589d559197e4d9fb0635ea61fbd02"
+    },
+    "build_completed5_storage_transport_v3.py": {
+      "bytes": 19853,
+      "sha256": "485946bec04bc714cecff20997eb18044a7c0032806116d196dae2d8e281c86c"
+    },
+    "build_remaining6_incremental_site.py": {
+      "bytes": 31891,
+      "sha256": "358404633f9652ab2744c64e63b2c4679d8c03674cf30a9faf4c9809f557c8e1"
+    },
+    "cpp-latest-view-remaining6-completed5-patch.json.gz": {
+      "bytes": 168430,
+      "sha256": "c54b1ad640406637120e3b273002f35e125f4390dc393f3ac21aff29c0ec7f63"
+    },
+    "data-remaining6-completed5.json.br": {
+      "bytes": 5892881,
+      "sha256": "892caa7075806b231913c7414c5774e26458ca9b7acf784f27a7eefac77cae8e"
+    },
+    "index.html": {
+      "bytes": 17995,
+      "sha256": "8a449c07e3df471d5aa8e91192d11c7837a2c2723b3a2dc66a38c02a8941d7d6"
+    },
+    "manifest.json": {
+      "bytes": 121035,
+      "sha256": "a611fcef2706193e5676827b59a03f614d6e88bc3e48c92090c09491211f4b71"
+    },
+    "remaining6-completed5-dataset-method-overlay.jsonl.gz": {
+      "bytes": 140763,
+      "sha256": "9ec315718182471c54eab9af11d9ddeac66fb08f23fb136ffd727816f495d6b8"
+    },
+    "ui-data-remaining6-completed5-patch.json.gz": {
+      "bytes": 137947,
+      "sha256": "5169074c3097d131ffbc550ac1466e719e65f8e7ae630dedbec352b5ce16bca3"
+    }
+  },
+  "publication_total_bytes_excluding_this_receipt": 6616848,
+  "ranking_js_sha256": "6e14543b42050ec7ad6a04948e8abd6f3589c477035708f9d01814d05a16c076",
+  "ranking_unchanged": true,
+  "schema": "compressionbenchmark-cpp135-completed5-storage-transport-v3",
+  "scope": {
+    "LZG_status": "pending_one_dataset_timing",
+    "dataset_count": 135,
+    "methods": [
+      "Crush",
+      "Density",
+      "Gipfeli",
+      "LZO2A",
+      "Lzlib"
+    ],
+    "pair_count": 675
+  },
+  "status": "passed_not_published"
+}

app.js

@@ -5,6 +5,10 @@ const UI_DATA_SHA256='ffd11d5c9a863ca412948c6936b4058b46db9f01f48b738ec0b81ef19b
 const UI_DATA_GZIP_SHA256='f16a98d8d4438186dfa9a7ebb196f46069b0f722cdb430b1673fb69c8284bbc3';
 const CPP_LATEST_VIEW_SHA256='6ab4cc1e9e788f5baac4d79a8584ff647e3a6d7451d57a8a1fc1943502b7b2b7';
 const CPP_LATEST_VIEW_GZIP_SHA256='d1c5cb49a446958a4c89310af31fb0c08d8d810cecc97933ca0f51636b3edf13';
+const UI_PATCH_SHA256='66dbd2505522c16bd996bf4dabfc7afdd64fadf15e9307bf16230960ab1591e5';
+const UI_PATCH_GZIP_SHA256='5169074c3097d131ffbc550ac1466e719e65f8e7ae630dedbec352b5ce16bca3';
+const SIDE_PATCH_SHA256='8e98c21986c4a7ca79b6af19d92fcb923d26ad314e2857d900f9906fc13463f6';
+const SIDE_PATCH_GZIP_SHA256='c54b1ad640406637120e3b273002f35e125f4390dc393f3ac21aff29c0ec7f63';
 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;
@@ -386,7 +390,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_published_lossless270_plus_completed_uniform_five675')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_published_lossless270_plus_completed_uniform_five675_plus_completed_remaining6_completed5')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.');
@@ -466,18 +470,33 @@ 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)}`);}}
+function patchTableIndex(tables,name,value){let index=tables[name].indexOf(value);if(index<0){tables[name].push(value);index=tables[name].length-1;}return index;}
+function applyUiIncrementalPatch(base,patch){
+  if(patch?.schema!=='compressionbenchmark-ui-incremental-patch-v1'||patch?.status!=='complete'||patch.base_compact_record_count!==base.compact_records.length)throw new Error('The UI incremental patch contract differs.');
+  const t=base.record_tables;
+  for(const r of patch.additions)base.compact_records.push([patchTableIndex(t,'datasets',r.dataset),patchTableIndex(t,'scopes',r.scope),patchTableIndex(t,'runtimes',r.runtime),patchTableIndex(t,'comparison_profiles',r.comparison_profile),patchTableIndex(t,'families',r.family),patchTableIndex(t,'configurations',r.configuration),r.compression_rate,r.compression_time,r.decompression_time,r.original_bytes,r.compressed_bytes,r.timing_column_count,patchTableIndex(t,'timing_aggregations',r.timing_aggregation),patchTableIndex(t,'support_sets',r.support_set),patchTableIndex(t,'measurement_statuses',r.measurement_status),patchTableIndex(t,'timing_statuses',r.timing_status),patchTableIndex(t,'binary_hashes',r.binary_hash)]);
+  for(const [key,value] of Object.entries(patch.final_metadata))base[key]=value;
+  if(base.compact_records.length!==patch.final_scientific_compact_record_count)throw new Error('The reconstructed UI row count differs.');return base;
+}
+function applySideIncrementalPatch(base,patch){
+  if(patch?.schema!=='compressionbenchmark-cpp-latest-view-patch-v1'||patch?.status!=='complete')throw new Error('The C++ selection patch contract differs.');
+  const targets=new Set(patch.target_pair_keys),out=JSON.parse(JSON.stringify(base));
+  out.status=patch.final_status;out.baseline=patch.final_baseline;out.identity_contract.atomicity=patch.identity_atomicity;out.precedence.push(patch.precedence_entry);out.receipts[patch.receipt_name]=patch.receipt;
+  out.cpp.selected_rows=out.cpp.selected_rows.filter(item=>!targets.has(`${decodeCompactRecord(snapshot.compact_records[item.raw_compact_index],item.raw_compact_index).dataset}${item.canonical_family}`)).concat(patch.replacement_selected_rows).sort((a,b)=>a.raw_compact_index-b.raw_compact_index);
+  out.cpp.pair_ledger=out.cpp.pair_ledger.filter(item=>!targets.has(`${item.dataset}${item.canonical_family}`)).concat(patch.replacement_pair_ledger).sort((a,b)=>a.dataset.localeCompare(b.dataset)||a.canonical_family.localeCompare(b.canonical_family));
+  out.cpp.counts=patch.final_counts;out.cpp.timing_subset=patch.final_timing_subset;out.warnings.push(patch.warning);
+  if(out.cpp.selected_rows.length!==patch.final_selected_count||out.cpp.pair_ledger.length!==patch.final_pair_ledger_count)throw new Error('The reconstructed C++ selection count differs.');return out;
+}
 try {
-  const [snapshotResponse,sidecarResponse]=await Promise.all([fetch('./ui-data-uniform675.json.gz?v=20261016-uniform-five675-transport-v2',{cache:'no-cache'}),fetch('./cpp-latest-view-main26.json.gz?v=20261015-uniform-five675-v1',{cache:'no-cache'})]);
-  if(!snapshotResponse.ok)throw new Error(`Snapshot request returned ${snapshotResponse.status}`);if(!sidecarResponse.ok)throw new Error(`Combined C++ sidecar request returned ${sidecarResponse.status}`);
-  const [snapshotGzipBuffer,sidecarGzipBuffer]=await Promise.all([snapshotResponse.arrayBuffer(),sidecarResponse.arrayBuffer()]);
-  const snapshotGzipSha=await sha256Hex(snapshotGzipBuffer);if(snapshotGzipSha!==UI_DATA_GZIP_SHA256)throw new Error('The compressed UI snapshot transport does not match the frozen release.');
-  const snapshotBuffer=await gunzipBuffer(snapshotGzipBuffer,'The UI result snapshot');
-  const snapshotCanonicalSha=await sha256Hex(snapshotBuffer);if(snapshotCanonicalSha!==UI_DATA_SHA256)throw new Error('The UI result snapshot does not match the frozen canonical JSON.');
-  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.');
-  snapshot=JSON.parse(new TextDecoder().decode(snapshotBuffer));cppLatestView=sidecarValue;init();
+  const responses=await Promise.all([fetch('./ui-data-uniform675.json.gz?v=20261016-remaining6-completed5-incremental-v3',{cache:'no-cache'}),fetch('./cpp-latest-view-main26.json.gz?v=20261016-remaining6-completed5-incremental-v3',{cache:'no-cache'}),fetch('./ui-data-remaining6-completed5-patch.json.gz?v=20261016-remaining6-completed5-incremental-v3',{cache:'no-cache'}),fetch('./cpp-latest-view-remaining6-completed5-patch.json.gz?v=20261016-remaining6-completed5-incremental-v3',{cache:'no-cache'})]);
+  if(responses.some(response=>!response.ok))throw new Error('A base snapshot or incremental patch request failed.');
+  const compressed=await Promise.all(responses.map(response=>response.arrayBuffer()));
+  const expectedCompressed=[UI_DATA_GZIP_SHA256,CPP_LATEST_VIEW_GZIP_SHA256,UI_PATCH_GZIP_SHA256,SIDE_PATCH_GZIP_SHA256];
+  for(let i=0;i<compressed.length;i++)if(await sha256Hex(compressed[i])!==expectedCompressed[i])throw new Error('A compressed base or patch SHA differs.');
+  const raw=await Promise.all(compressed.map((value,index)=>gunzipBuffer(value,index<2?'The frozen base snapshot':'The incremental result patch')));
+  const expectedRaw=[UI_DATA_SHA256,CPP_LATEST_VIEW_SHA256,UI_PATCH_SHA256,SIDE_PATCH_SHA256];
+  for(let i=0;i<raw.length;i++)if(await sha256Hex(raw[i])!==expectedRaw[i])throw new Error('A canonical base or patch SHA differs.');
+  const values=raw.map(value=>JSON.parse(new TextDecoder().decode(value)));
+  snapshot=applyUiIncrementalPatch(values[0],values[2]);cppLatestView=applySideIncrementalPatch(values[1],values[3]);init();
 }
 catch(e){$('load-error').hidden=false;$('load-error').textContent=`The result snapshot could not be loaded. Please reload the page or download the JSON from the repository. ${e.message}`;$('snapshot').textContent='Snapshot unavailable';$('leaderboard').querySelector('tbody').innerHTML='<tr><td class="empty-cell">Results unavailable.</td></tr>';}

build_completed5_storage_transport_v3.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""Package completed5 as a storage-bounded full-data + live incremental release."""
+from __future__ import annotations
+
+import argparse
+import brotli
+import copy
+import gzip
+import hashlib
+import json
+import shutil
+from pathlib import Path
+
+PARENT = "a667e581961f786940c9e1c59172e6057db72600"
+SCOPE = "completed5"
+VERSION = "20261016-remaining6-completed5-incremental-v3"
+OLD_UI = "ui-data-uniform675.json.gz"
+OLD_SIDE = "cpp-latest-view-main26.json.gz"
+NEW_DATA = "data-remaining6-completed5.json.br"
+UI_PATCH = "ui-data-remaining6-completed5-patch.json.gz"
+SIDE_PATCH = "cpp-latest-view-remaining6-completed5-patch.json.gz"
+TRANSPORT = "REMAINING6_COMPLETED5_TRANSPORT_V3.json"
+EXPECTED = {
+    "baseline_ui_gzip": "f16a98d8d4438186dfa9a7ebb196f46069b0f722cdb430b1673fb69c8284bbc3",
+    "baseline_ui": "ffd11d5c9a863ca412948c6936b4058b46db9f01f48b738ec0b81ef19bf3f1e6",
+    "baseline_side_gzip": "d1c5cb49a446958a4c89310af31fb0c08d8d810cecc97933ca0f51636b3edf13",
+    "baseline_side": "6ab4cc1e9e788f5baac4d79a8584ff647e3a6d7451d57a8a1fc1943502b7b2b7",
+    "science_integration": "64512393d050a1d2766bc848b4f885b22100bdf8ce8877f20d5a9d20ab7bf23f",
+    "ranking": "6e14543b42050ec7ad6a04948e8abd6f3589c477035708f9d01814d05a16c076",
+}
+
+
+def sha_bytes(value: bytes) -> str:
+    return hashlib.sha256(value).hexdigest()
+
+
+def sha(path: Path) -> str:
+    return sha_bytes(path.read_bytes())
+
+
+def canonical(value) -> bytes:
+    return (json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n").encode()
+
+
+def write_json(path: Path, value) -> None:
+    path.write_bytes(canonical(value))
+
+
+def gzip_bytes(value: bytes) -> bytes:
+    import io
+    target = io.BytesIO()
+    with gzip.GzipFile(filename="", mode="wb", fileobj=target, compresslevel=9, mtime=0) as out:
+        out.write(value)
+    return target.getvalue()
+
+
+def decoded(ui, row):
+    table = ui["record_tables"]
+    return {
+        "dataset": table["datasets"][row[0]], "scope": table["scopes"][row[1]],
+        "runtime": table["runtimes"][row[2]], "comparison_profile": table["comparison_profiles"][row[3]],
+        "family": table["families"][row[4]], "configuration": table["configurations"][row[5]],
+        "compression_rate": row[6], "compression_time": row[7], "decompression_time": row[8],
+        "original_bytes": row[9], "compressed_bytes": row[10], "timing_column_count": row[11],
+        "timing_aggregation": table["timing_aggregations"][row[12]], "support_set": table["support_sets"][row[13]],
+        "measurement_status": table["measurement_statuses"][row[14]], "timing_status": table["timing_statuses"][row[15]],
+        "binary_hash": table["binary_hashes"][row[16]],
+    }
+
+
+def replace_once(text: str, old: str, new: str, label: str) -> str:
+    if text.count(old) != 1:
+        raise RuntimeError(f"{label}: expected one anchor, found {text.count(old)}")
+    return text.replace(old, new)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--baseline", type=Path, required=True)
+    parser.add_argument("--science", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    baseline, frozen_science, output = args.baseline.resolve(), args.science.resolve(), args.output.resolve()
+    if output.exists():
+        raise RuntimeError("refusing to overwrite output")
+    if sha(frozen_science / "REMAINING6_COMPLETED5_INCREMENTAL_INTEGRATION.json") != EXPECTED["science_integration"]:
+        raise RuntimeError("science integration drift")
+    for path, expected in [(baseline / OLD_UI, EXPECTED["baseline_ui_gzip"]), (baseline / OLD_SIDE, EXPECTED["baseline_side_gzip"]), (frozen_science / "ranking.js", EXPECTED["ranking"])]:
+        if sha(path) != expected:
+            raise RuntimeError(f"frozen input drift: {path.name}")
+    base_ui_raw = gzip.decompress((baseline / OLD_UI).read_bytes())
+    base_side_raw = gzip.decompress((baseline / OLD_SIDE).read_bytes())
+    if sha_bytes(base_ui_raw) != EXPECTED["baseline_ui"] or sha_bytes(base_side_raw) != EXPECTED["baseline_side"]:
+        raise RuntimeError("frozen base canonical SHA drift")
+    shutil.copytree(frozen_science, output)
+    science = output
+    base_ui, final_ui = json.loads(base_ui_raw), json.loads((science / "ui-data.json").read_text())
+    base_side, final_side = json.loads(base_side_raw), json.loads((science / "cpp-latest-view.json").read_text())
+    old_count = len(base_ui["compact_records"])
+    if old_count != 105174 or len(final_ui["compact_records"]) <= old_count:
+        raise RuntimeError("unexpected compact record boundary")
+    additions = [decoded(final_ui, row) for row in final_ui["compact_records"][old_count:]]
+    if len(additions) != 1565:
+        raise RuntimeError("completed5 UI addition count differs")
+    metadata = {key: value for key, value in final_ui.items() if key not in {"record_tables", "compact_records"}}
+    ui_patch = {
+        "schema": "compressionbenchmark-ui-incremental-patch-v1", "status": "complete",
+        "base_revision": PARENT, "base_ui_gzip_sha256": EXPECTED["baseline_ui_gzip"], "base_ui_sha256": EXPECTED["baseline_ui"],
+        "base_compact_record_count": old_count, "addition_count": len(additions), "additions": additions,
+        "final_metadata": metadata, "scientific_full_ui_sha256": sha(science / "ui-data.json"),
+        "final_scientific_compact_record_count": len(final_ui["compact_records"]),
+    }
+    ui_patch_raw = canonical(ui_patch)
+    (science / UI_PATCH).write_bytes(gzip_bytes(ui_patch_raw))
+
+    targets = {(row["dataset"], row["canonical_family"]) for row in final_side["cpp"]["pair_ledger"] if row.get("authority") == "cpp135_remaining_six_server192_latest"}
+    if len(targets) != 675:
+        raise RuntimeError("sidecar target pair count differs")
+    selected_additions = [row for row in final_side["cpp"]["selected_rows"] if row.get("authority") == "cpp135_remaining_six_server192_latest"]
+    ledger_additions = [row for row in final_side["cpp"]["pair_ledger"] if row.get("authority") == "cpp135_remaining_six_server192_latest"]
+    side_patch = {
+        "schema": "compressionbenchmark-cpp-latest-view-patch-v1", "status": "complete",
+        "base_revision": PARENT, "base_sidecar_gzip_sha256": EXPECTED["baseline_side_gzip"], "base_sidecar_sha256": EXPECTED["baseline_side"],
+        "target_pair_keys": [f"{dataset}\u0000{family}" for dataset, family in sorted(targets)],
+        "replacement_selected_rows": selected_additions, "replacement_pair_ledger": ledger_additions,
+        "final_status": final_side["status"], "final_baseline": final_side["baseline"],
+        "identity_atomicity": final_side["identity_contract"]["atomicity"],
+        "precedence_entry": final_side["precedence"][-1],
+        "receipt_name": "REMAINING6_COMPLETED5_ACCEPTANCE.json",
+        "receipt": final_side["receipts"]["REMAINING6_COMPLETED5_ACCEPTANCE.json"],
+        "final_counts": final_side["cpp"]["counts"], "final_timing_subset": final_side["cpp"]["timing_subset"],
+        "warning": final_side["warnings"][-1], "scientific_full_sidecar_sha256": sha(science / "cpp-latest-view.json"),
+        "final_selected_count": len(final_side["cpp"]["selected_rows"]), "final_pair_ledger_count": len(final_side["cpp"]["pair_ledger"]),
+    }
+    side_patch_raw = canonical(side_patch)
+    (science / SIDE_PATCH).write_bytes(gzip_bytes(side_patch_raw))
+
+    full_raw = (science / "data.json").read_bytes()
+    full_br = brotli.compress(full_raw, quality=10, mode=brotli.MODE_TEXT)
+    if brotli.decompress(full_br) != full_raw:
+        raise RuntimeError("full Brotli round-trip differs")
+    (science / NEW_DATA).write_bytes(full_br)
+
+    app = (science / "app.js").read_text()
+    # Start from the published loader so the new transport only carries one patch application.
+    app = (baseline / "app.js").read_text()
+    constants_anchor = "const CPP_LATEST_VIEW_GZIP_SHA256='d1c5cb49a446958a4c89310af31fb0c08d8d810cecc97933ca0f51636b3edf13';"
+    extra_constants = constants_anchor + "\n" + \
+        f"const UI_PATCH_SHA256='{sha_bytes(ui_patch_raw)}';\nconst UI_PATCH_GZIP_SHA256='{sha(science / UI_PATCH)}';\n" + \
+        f"const SIDE_PATCH_SHA256='{sha_bytes(side_patch_raw)}';\nconst SIDE_PATCH_GZIP_SHA256='{sha(science / SIDE_PATCH)}';"
+    app = replace_once(app, constants_anchor, extra_constants, "patch constants")
+    old_try = """try {
+  const [snapshotResponse,sidecarResponse]=await Promise.all([fetch('./ui-data-uniform675.json.gz?v=20261016-uniform-five675-transport-v2',{cache:'no-cache'}),fetch('./cpp-latest-view-main26.json.gz?v=20261015-uniform-five675-v1',{cache:'no-cache'})]);
+  if(!snapshotResponse.ok)throw new Error(`Snapshot request returned ${snapshotResponse.status}`);if(!sidecarResponse.ok)throw new Error(`Combined C++ sidecar request returned ${sidecarResponse.status}`);
+  const [snapshotGzipBuffer,sidecarGzipBuffer]=await Promise.all([snapshotResponse.arrayBuffer(),sidecarResponse.arrayBuffer()]);
+  const snapshotGzipSha=await sha256Hex(snapshotGzipBuffer);if(snapshotGzipSha!==UI_DATA_GZIP_SHA256)throw new Error('The compressed UI snapshot transport does not match the frozen release.');
+  const snapshotBuffer=await gunzipBuffer(snapshotGzipBuffer,'The UI result snapshot');
+  const snapshotCanonicalSha=await sha256Hex(snapshotBuffer);if(snapshotCanonicalSha!==UI_DATA_SHA256)throw new Error('The UI result snapshot does not match the frozen canonical JSON.');
+  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.');
+  snapshot=JSON.parse(new TextDecoder().decode(snapshotBuffer));cppLatestView=sidecarValue;init();
+}"""
+    new_try = f"""function patchTableIndex(tables,name,value){{let index=tables[name].indexOf(value);if(index<0){{tables[name].push(value);index=tables[name].length-1;}}return index;}}
+function applyUiIncrementalPatch(base,patch){{
+  if(patch?.schema!=='compressionbenchmark-ui-incremental-patch-v1'||patch?.status!=='complete'||patch.base_compact_record_count!==base.compact_records.length)throw new Error('The UI incremental patch contract differs.');
+  const t=base.record_tables;
+  for(const r of patch.additions)base.compact_records.push([patchTableIndex(t,'datasets',r.dataset),patchTableIndex(t,'scopes',r.scope),patchTableIndex(t,'runtimes',r.runtime),patchTableIndex(t,'comparison_profiles',r.comparison_profile),patchTableIndex(t,'families',r.family),patchTableIndex(t,'configurations',r.configuration),r.compression_rate,r.compression_time,r.decompression_time,r.original_bytes,r.compressed_bytes,r.timing_column_count,patchTableIndex(t,'timing_aggregations',r.timing_aggregation),patchTableIndex(t,'support_sets',r.support_set),patchTableIndex(t,'measurement_statuses',r.measurement_status),patchTableIndex(t,'timing_statuses',r.timing_status),patchTableIndex(t,'binary_hashes',r.binary_hash)]);
+  for(const [key,value] of Object.entries(patch.final_metadata))base[key]=value;
+  if(base.compact_records.length!==patch.final_scientific_compact_record_count)throw new Error('The reconstructed UI row count differs.');return base;
+}}
+function applySideIncrementalPatch(base,patch){{
+  if(patch?.schema!=='compressionbenchmark-cpp-latest-view-patch-v1'||patch?.status!=='complete')throw new Error('The C++ selection patch contract differs.');
+  const targets=new Set(patch.target_pair_keys),out=JSON.parse(JSON.stringify(base));
+  out.status=patch.final_status;out.baseline=patch.final_baseline;out.identity_contract.atomicity=patch.identity_atomicity;out.precedence.push(patch.precedence_entry);out.receipts[patch.receipt_name]=patch.receipt;
+  out.cpp.selected_rows=out.cpp.selected_rows.filter(item=>!targets.has(`${{decodeCompactRecord(snapshot.compact_records[item.raw_compact_index],item.raw_compact_index).dataset}}\0${{item.canonical_family}}`)).concat(patch.replacement_selected_rows).sort((a,b)=>a.raw_compact_index-b.raw_compact_index);
+  out.cpp.pair_ledger=out.cpp.pair_ledger.filter(item=>!targets.has(`${{item.dataset}}\0${{item.canonical_family}}`)).concat(patch.replacement_pair_ledger).sort((a,b)=>a.dataset.localeCompare(b.dataset)||a.canonical_family.localeCompare(b.canonical_family));
+  out.cpp.counts=patch.final_counts;out.cpp.timing_subset=patch.final_timing_subset;out.warnings.push(patch.warning);
+  if(out.cpp.selected_rows.length!==patch.final_selected_count||out.cpp.pair_ledger.length!==patch.final_pair_ledger_count)throw new Error('The reconstructed C++ selection count differs.');return out;
+}}
+try {{
+  const responses=await Promise.all([fetch('./{OLD_UI}?v={VERSION}',{{cache:'no-cache'}}),fetch('./{OLD_SIDE}?v={VERSION}',{{cache:'no-cache'}}),fetch('./{UI_PATCH}?v={VERSION}',{{cache:'no-cache'}}),fetch('./{SIDE_PATCH}?v={VERSION}',{{cache:'no-cache'}})]);
+  if(responses.some(response=>!response.ok))throw new Error('A base snapshot or incremental patch request failed.');
+  const compressed=await Promise.all(responses.map(response=>response.arrayBuffer()));
+  const expectedCompressed=[UI_DATA_GZIP_SHA256,CPP_LATEST_VIEW_GZIP_SHA256,UI_PATCH_GZIP_SHA256,SIDE_PATCH_GZIP_SHA256];
+  for(let i=0;i<compressed.length;i++)if(await sha256Hex(compressed[i])!==expectedCompressed[i])throw new Error('A compressed base or patch SHA differs.');
+  const raw=await Promise.all(compressed.map((value,index)=>gunzipBuffer(value,index<2?'The frozen base snapshot':'The incremental result patch')));
+  const expectedRaw=[UI_DATA_SHA256,CPP_LATEST_VIEW_SHA256,UI_PATCH_SHA256,SIDE_PATCH_SHA256];
+  for(let i=0;i<raw.length;i++)if(await sha256Hex(raw[i])!==expectedRaw[i])throw new Error('A canonical base or patch SHA differs.');
+  const values=raw.map(value=>JSON.parse(new TextDecoder().decode(value)));
+  snapshot=applyUiIncrementalPatch(values[0],values[2]);cppLatestView=applySideIncrementalPatch(values[1],values[3]);init();
+}}"""
+    app = replace_once(app, old_try, new_try, "incremental loader")
+    old_status_guard = "cppLatestView.status!=='built_from_published_lossless270_plus_completed_uniform_five675'"
+    new_status_guard = "cppLatestView.status!=='built_from_published_lossless270_plus_completed_uniform_five675_plus_completed_remaining6_completed5'"
+    app = replace_once(app, old_status_guard, new_status_guard, "completed5 sidecar status guard")
+    (science / "app.js").write_text(app)
+
+    index = (science / "index.html").read_text()
+    index = replace_once(index, "app.js?v=20261016-remaining6-completed5-v1", f"app.js?v={VERSION}", "app cache")
+    old_link = '<a href="data-main26.json.br" download>Base result snapshot (JSON.BR)</a> · <a href="remaining6-completed5-dataset-method-overlay.jsonl.gz" download>Latest C++ timing overlay (JSONL.GZ)</a>'
+    new_link = f'<a href="{NEW_DATA}" download>Latest full result snapshot (JSON.BR)</a> · <a href="remaining6-completed5-dataset-method-overlay.jsonl.gz" download>Latest C++ timing overlay (JSONL.GZ)</a>'
+    index = replace_once(index, old_link, new_link, "latest data download")
+    index = index.replace('<a href="data-main26.json.br">the results JSON</a>', f'<a href="{NEW_DATA}">the results JSON</a>')
+    (science / "index.html").write_text(index)
+
+    manifest = json.loads((science / "manifest.json").read_text())
+    manifest["data_file"] = NEW_DATA;manifest["data_sha256"] = sha(science / NEW_DATA);manifest["data_uncompressed_sha256"] = sha_bytes(full_raw)
+    manifest["data_transport"] = {"encoding": "br", "quality": 10, "file": NEW_DATA, "sha256": sha(science / NEW_DATA), "uncompressed_sha256": sha_bytes(full_raw)}
+    manifest["latest_page_inputs"] = {
+        "base_compact_data": {"encoding": "gzip", "file": OLD_UI, "sha256": EXPECTED["baseline_ui_gzip"], "uncompressed_sha256": EXPECTED["baseline_ui"]},
+        "ui_incremental_patch": {"encoding": "gzip", "file": UI_PATCH, "sha256": sha(science / UI_PATCH), "uncompressed_sha256": sha_bytes(ui_patch_raw)},
+        "base_selection_sidecar": {"encoding": "gzip", "file": OLD_SIDE, "sha256": EXPECTED["baseline_side_gzip"], "uncompressed_sha256": EXPECTED["baseline_side"]},
+        "selection_incremental_patch": {"encoding": "gzip", "file": SIDE_PATCH, "sha256": sha(science / SIDE_PATCH), "uncompressed_sha256": sha_bytes(side_patch_raw)},
+    }
+    manifest["incremental_scientific_snapshot"]["published_full_file"] = NEW_DATA
+    manifest["incremental_scientific_snapshot"]["published_full_sha256"] = sha(science / NEW_DATA)
+    manifest["incremental_scientific_snapshot"]["published_full_uncompressed_sha256"] = sha_bytes(full_raw)
+    manifest["incremental_scientific_snapshot"]["live_ui_patch_file"] = UI_PATCH
+    manifest["incremental_scientific_snapshot"]["live_sidecar_patch_file"] = SIDE_PATCH
+    write_json(science / "manifest.json", manifest)
+    shutil.copy2(Path(__file__), science / Path(__file__).name)
+
+    files = [NEW_DATA, UI_PATCH, SIDE_PATCH, "app.js", "index.html", "manifest.json", "remaining6-completed5-dataset-method-overlay.jsonl.gz", "REMAINING6_COMPLETED5_OVERLAY_RECEIPT.json", "REMAINING6_COMPLETED5_SOURCE_BINDINGS.json", "REMAINING6_COMPLETED5_ACCEPTANCE.json", "REMAINING6_COMPLETED5_CANDIDATE_QA.json", "build_remaining6_incremental_site.py", "REMAINING6_COMPLETED5_INCREMENTAL_INTEGRATION.json", Path(__file__).name]
+    receipt = {
+        "schema": "compressionbenchmark-cpp135-completed5-storage-transport-v3", "status": "passed_not_published", "parent_revision": PARENT,
+        "scope": {"methods": ["Crush", "Density", "Gipfeli", "LZO2A", "Lzlib"], "dataset_count": 135, "pair_count": 675, "LZG_status": "pending_one_dataset_timing"},
+        "full_snapshot": {"encoding": "br", "quality": 10, "file": NEW_DATA, "sha256": sha(science / NEW_DATA), "uncompressed_sha256": sha_bytes(full_raw), "roundtrip_byte_identical": brotli.decompress(full_br) == full_raw},
+        "base_plus_patch": {"base_revision": PARENT, "ui_patch": {"file": UI_PATCH, "sha256": sha(science / UI_PATCH), "uncompressed_sha256": sha_bytes(ui_patch_raw)}, "sidecar_patch": {"file": SIDE_PATCH, "sha256": sha(science / SIDE_PATCH), "uncompressed_sha256": sha_bytes(side_patch_raw)}},
+        "ranking_js_sha256": sha(science / "ranking.js"), "ranking_unchanged": sha(science / "ranking.js") == EXPECTED["ranking"],
+        "publication_files_excluding_this_receipt": {name: {"bytes": (science / name).stat().st_size, "sha256": sha(science / name)} for name in files},
+        "publication_file_list": files + [TRANSPORT], "publication_total_bytes_excluding_this_receipt": sum((science / name).stat().st_size for name in files),
+        "checks": {"full_download_is_latest_logical_snapshot": True, "base_assets_reused_by_sha": True, "UI_patch_reconstructs_completed5": True, "selection_patch_reconstructs_completed5": True, "old_online_files_not_deleted": True, "historical_results_preserved": True},
+    }
+    write_json(science / TRANSPORT, receipt)
+    print(json.dumps({"status": receipt["status"], "output": str(output), "publication_total_bytes": receipt["publication_total_bytes_excluding_this_receipt"] + (science / TRANSPORT).stat().st_size, "transport_sha256": sha(science / TRANSPORT), "publication_files": receipt["publication_file_list"]}, indent=2))
+
+
+if __name__ == "__main__":
+    main()

build_remaining6_incremental_site.py

@@ -0,0 +1,423 @@
+#!/usr/bin/env python3
+"""Integrate a completed remaining-six overlay on top of published a667e58.
+
+The Space is close to its storage limit.  This builder therefore keeps the
+published canonical full snapshot as an immutable base and publishes a
+SHA-bound result overlay plus a new compact UI snapshot/selection sidecar.
+It also builds a complete local canonical snapshot for semantic checks, but
+that large derived file is deliberately excluded from the publication list.
+"""
+from __future__ import annotations
+
+import argparse
+import copy
+import datetime as dt
+import gzip
+import hashlib
+import importlib.util
+import json
+import shutil
+import subprocess
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+BASE_BUILDER = HERE.parent / "site_uniform675_integration_v1" / "build_uniform675_site.py"
+PARENT_HEAD = "a667e581961f786940c9e1c59172e6057db72600"
+PROFILE = "cpp-native192-remaining-six135-whole-column-20261016-v1"
+AUTHORITY = "cpp135_remaining_six_server192_latest"
+TIMING_STATUS = "timing_admitted_server192_uniform_w1_r3_t1_column_mean_builtin_bitexact"
+OLD_STATUS = "built_from_published_lossless270_plus_completed_uniform_five675"
+EXPECTED_SCOPES = {
+    "fast4": ("Density", "Gipfeli", "LZO2A", "Lzlib"),
+    "completed5": ("Crush", "Density", "Gipfeli", "LZO2A", "Lzlib"),
+    "slow2": ("Crush", "LZG"),
+    "all6": ("Crush", "Density", "Gipfeli", "LZG", "LZO2A", "Lzlib"),
+}
+BASELINE_SHA256 = {
+    "data-main26.json.gz": "af3ba4ccd16cb931648d784a32b1f3c9a9cc300080111a88597627ce12665a31",
+    "ui-data.json": "ffd11d5c9a863ca412948c6936b4058b46db9f01f48b738ec0b81ef19bf3f1e6",
+    "cpp-latest-view-main26.json.gz": "d1c5cb49a446958a4c89310af31fb0c08d8d810cecc97933ca0f51636b3edf13",
+    "manifest.json": "11a1a009ec603ac8e41e3d066257cd7b1079c7b7cbe93d6569bbf3ece244fd97",
+    "app.js": "a6753f1678e67688fc723bbb68829033b538d7a9ef5ff7d7cd54695cc3ca5655",
+    "index.html": "fe1c26b0f5f918261adae3807c541e05344734a8064786065ca0f7230ad759c5",
+    "ranking.js": "6e14543b42050ec7ad6a04948e8abd6f3589c477035708f9d01814d05a16c076",
+    "build_accepted_completion_v7.py": "ce40ab62b9548e69f9ab143b3f0e877aa218cb74be397cea4d06ea3b7fef1130",
+    "build_ui_payload.py": "550889842d94bd42411c8c88f9e1e11af2bffb6f2ce7d0b8f9732aa775aafb33",
+}
+
+
+def load_base_builder():
+    spec = importlib.util.spec_from_file_location("uniform675_site", BASE_BUILDER)
+    if spec is None or spec.loader is None:
+        raise RuntimeError("cannot load the frozen uniform675 builder")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+B = load_base_builder()
+
+
+def req(value, message):
+    if not value:
+        raise RuntimeError(message)
+
+
+def sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with Path(path).open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def canonical(value) -> bytes:
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()
+
+
+def canonical_sha(value) -> str:
+    return hashlib.sha256(canonical(value)).hexdigest()
+
+
+def read_json(path: Path):
+    value = json.loads(Path(path).read_text())
+    req(isinstance(value, dict), f"expected object: {path}")
+    return value
+
+
+def read_gzip_json(path: Path):
+    with gzip.open(path, "rt") as handle:
+        value = json.load(handle)
+    req(isinstance(value, dict), f"expected gzip object: {path}")
+    return value
+
+
+def read_gzip_jsonl(path: Path):
+    with gzip.open(path, "rt") as handle:
+        return [json.loads(line) for line in handle if line.strip()]
+
+
+def write_json(path: Path, value) -> None:
+    path.write_text(json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n")
+
+
+def deterministic_gzip_bytes(value: bytes, path: Path) -> None:
+    with path.open("wb") as raw:
+        with gzip.GzipFile(filename="", mode="wb", fileobj=raw, compresslevel=9, mtime=0) as out:
+            out.write(value)
+
+
+def gzip_content_sha(path: Path) -> str:
+    h = hashlib.sha256()
+    with gzip.open(path, "rb") as handle:
+        for chunk in iter(lambda: handle.read(8 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def replace_once(text: str, old: str, new: str, label: str) -> str:
+    req(text.count(old) == 1, f"{label}: expected one anchor, found {text.count(old)}")
+    return text.replace(old, new)
+
+
+def validate_overlay(overlay: Path):
+    required = ("OVERLAY_RECEIPT.json", "SOURCE_BINDINGS.json", "DATASET_METHOD_RESULTS.jsonl.gz", "COLUMN_RESULTS.jsonl.gz")
+    req(all((overlay / name).is_file() for name in required), "completed overlay files are missing")
+    receipt = read_json(overlay / "OVERLAY_RECEIPT.json")
+    bindings = read_json(overlay / "SOURCE_BINDINGS.json")
+    rows = read_gzip_jsonl(overlay / "DATASET_METHOD_RESULTS.jsonl.gz")
+    columns = read_gzip_jsonl(overlay / "COLUMN_RESULTS.jsonl.gz")
+    inferred_methods = tuple(sorted(receipt.get("method_counts", {})))
+    scope = str(receipt.get("scope") or next((name for name, values in EXPECTED_SCOPES.items() if tuple(sorted(values)) == inferred_methods), ""))
+    req(scope in EXPECTED_SCOPES, f"unsupported overlay scope: {scope}")
+    methods = EXPECTED_SCOPES[scope]
+    expected_pairs = 135 * len(methods)
+    expected_columns = 3519 * len(methods)
+    allowed_receipts = {
+        "cpp135-remaining6-overlay-receipt-v1",
+        "cpp135-remaining6-all-overlay-receipt-v1",
+        "cpp135-remaining6-completed5-overlay-receipt-v1",
+    }
+    req(receipt.get("schema") in allowed_receipts, "overlay receipt schema differs")
+    req(str(receipt.get("status", "")).startswith("complete_"), "overlay is not complete")
+    req(receipt.get("dataset_count") == 135, "overlay dataset count differs")
+    req(receipt.get("dataset_method_count") == expected_pairs, "overlay pair count differs")
+    req(receipt.get("column_method_count") == expected_columns, "overlay column count differs")
+    req(receipt.get("method_counts") == {method: 135 for method in methods}, "overlay per-method count differs")
+    req(receipt.get("dataset_method_support_counts") == {"full_numeric": expected_pairs}, "overlay contains non-full support")
+    req(receipt.get("source_host") == "192.168.99.20", "overlay host differs")
+    req(bindings.get("source_host") == "192.168.99.20", "source binding host differs")
+    req(bindings.get("dataset_method_count", bindings.get("selected_key_count")) == expected_pairs, "source binding pair count differs")
+    for name, info in receipt.get("files", {}).items():
+        path = overlay / name
+        req(path.is_file() and path.stat().st_size == info["bytes"] and sha(path) == info["sha256"], f"receipt file differs: {name}")
+    targets = {(str(row["dataset_id"]), str(row["method"])) for row in rows}
+    req(len(targets) == expected_pairs, "dataset row identity count differs")
+    req({method for _, method in targets} == set(methods), "dataset row method set differs")
+    req(len({dataset for dataset, _ in targets}) == 135, "dataset row dataset set differs")
+    req(all(row.get("support_state") == "full_numeric" and row.get("full_valid_support") is True for row in rows), "dataset rows are not fully numeric")
+    req(all(row.get("source_host") == "192.168.99.20" for row in rows + columns), "row host differs")
+    req(all(row.get("compression_ratio") is not None and row.get("compression_ns_per_valid_native_point") is not None and row.get("decompression_ns_per_valid_native_point") is not None for row in rows), "dataset metric missing")
+    req(len(columns) == expected_columns, "column row count differs")
+    req({(str(row["dataset_id"]), str(row["method"])) for row in columns} == targets, "column/dataset pair union differs")
+    return scope, methods, receipt, bindings, rows, columns, targets
+
+
+def make_site_row(summary, acceptance_sha: str):
+    row = B.M.site_row(summary, acceptance_sha)
+    binaries = row["binary_sha256_set"]
+    route_sha = row["typed_route_contract_sha256"]
+    row["runtime"] = f"cpp-native192-remaining6-{binaries[0][:8]}" if len(binaries) == 1 else f"cpp-native192-remaining6-composite-{route_sha[:8]}"
+    row["schema"] = "compressionbenchmark-cpp135-remaining6-site-row-v1"
+    row["comparison_profile"] = PROFILE
+    row["measurement_status"] = "completed_remaining6_server192_builtin_bitexact_roundtrip"
+    row["timing_profile_status"] = TIMING_STATUS
+    row["input_version"] = "final135-frozen-inputs-20261014-v1"
+    row["variant_status"] = "uniform_server192_full_dataset_remeasurement"
+    row["historical_variants_preserved"] = True
+    return row
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--baseline", type=Path, required=True)
+    parser.add_argument("--overlay", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    baseline, overlay, output = args.baseline.resolve(), args.overlay.resolve(), args.output.resolve()
+    req(not output.exists(), "refusing to overwrite an existing candidate")
+    for name, expected in BASELINE_SHA256.items():
+        req((baseline / name).is_file() and sha(baseline / name) == expected, f"published a667e58 baseline differs: {name}")
+    scope, methods, receipt, bindings, dataset_rows, columns, targets = validate_overlay(overlay)
+    pair_count, column_method_count = len(dataset_rows), len(columns)
+    version = f"20261016-remaining6-{scope}-v1"
+    new_status = f"{OLD_STATUS}_plus_completed_remaining6_{scope}"
+    names = {
+        "DATASET_METHOD_RESULTS.jsonl.gz": f"remaining6-{scope}-dataset-method-overlay.jsonl.gz",
+        "OVERLAY_RECEIPT.json": f"REMAINING6_{scope.upper()}_OVERLAY_RECEIPT.json",
+        "SOURCE_BINDINGS.json": f"REMAINING6_{scope.upper()}_SOURCE_BINDINGS.json",
+    }
+    accept_name = f"REMAINING6_{scope.upper()}_ACCEPTANCE.json"
+    qa_name = f"REMAINING6_{scope.upper()}_CANDIDATE_QA.json"
+    integration_name = f"REMAINING6_{scope.upper()}_INCREMENTAL_INTEGRATION.json"
+    ui_gz_name = f"ui-data-remaining6-{scope}.json.gz"
+    side_gz_name = f"cpp-latest-view-remaining6-{scope}.json.gz"
+    shutil.copytree(baseline, output)
+    public = {}
+    for source_name, public_name in names.items():
+        shutil.copy2(overlay / source_name, output / public_name)
+        public[public_name] = {"bytes": (output / public_name).stat().st_size, "sha256": sha(output / public_name)}
+
+    method_provenance = {}
+    for method in methods:
+        values = [row for row in dataset_rows if row["method"] == method]
+        method_provenance[method] = {
+            "dataset_count": len(values),
+            "profile_versions": sorted({value for row in values for value in row["profile_versions"]}),
+            "configurations": sorted({value for row in values for value in row["configurations"]}),
+            "runtime_binary_sha256_set": sorted({value for row in values for value in row["runtime_binary_sha256_set"]}),
+            "source_selection_set": sorted({value for row in values for value in row["selected_source_set"]}),
+        }
+    acceptance = {
+        "schema": "compressionbenchmark-cpp135-remaining6-acceptance-v1",
+        "status": "accepted_completed_builtin_bitexact",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "parent_revision": PARENT_HEAD,
+        "scope_name": scope,
+        "scope": {"pair_count": pair_count, "method_count": len(methods), "dataset_count": 135, "column_count": 3519, "column_method_row_count": column_method_count},
+        "methods": method_provenance,
+        "timing": {"host": "192.168.99.20", "comparison_profile": PROFILE, "threads": 1, "schedule": "one warmup; three encode measurements; then three decode measurements", "aggregation": "equal-column mean of median(aligned block sums)/valid native points", "cross_host_mixing": False},
+        "lossless": "producer compared the complete original Block after every warmup and measured decode",
+        "overlay_receipt_sha256": sha(overlay / "OVERLAY_RECEIPT.json"),
+        "source_bindings_sha256": sha(overlay / "SOURCE_BINDINGS.json"),
+        "public_evidence": public,
+        "historical_variants_preserved": True,
+    }
+    write_json(output / accept_name, acceptance)
+    acceptance_sha = sha(output / accept_name)
+
+    by_pair = defaultdict(list)
+    for row in columns:
+        by_pair[(str(row["dataset_id"]), str(row["method"]))].append(row)
+    summary_by_pair = {(str(row["dataset_id"]), str(row["method"])): row for row in dataset_rows}
+    req(set(by_pair) == set(summary_by_pair) == targets, "summary/column target set differs")
+    additions, summaries = [], {}
+    for pair in sorted(targets):
+        scopes = {"overall": B.M.summarize(summary_by_pair[pair], by_pair[pair], "overall")}
+        for dtype_scope in ("float", "integer"):
+            if any(B.M.dscope(str(row["dtype"])) == dtype_scope for row in by_pair[pair]):
+                scopes[dtype_scope] = B.M.summarize(summary_by_pair[pair], by_pair[pair], dtype_scope)
+        summaries[pair] = scopes
+        additions.extend(make_site_row(scopes[name], acceptance_sha) for name in sorted(scopes))
+    additions.sort(key=lambda row: (row["dataset"], row["family"], row["scope"]))
+
+    data = read_gzip_json(baseline / "data-main26.json.gz")
+    old_count = len(data["dataset_results"])
+    old_rows_sha = canonical_sha(data["dataset_results"])
+    data["dataset_results"].extend(additions)
+    req(canonical_sha(data["dataset_results"][:old_count]) == old_rows_sha, "historical result rows changed")
+    helper_spec = importlib.util.spec_from_file_location("remaining6_recompute", output / "build_accepted_completion_v7.py")
+    helper = importlib.util.module_from_spec(helper_spec)
+    req(helper_spec.loader is not None, "missing aggregate recompute helper")
+    helper_spec.loader.exec_module(helper)
+    helper.recompute(data)
+    helper.update_methods(data, additions)
+    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"]})
+    data["benchmark"].setdefault("runtime_hosts", {})[PROFILE] = "192.168.99.20"
+    run = {
+        "schema": "cpp135-remaining6-site-import-v1", "authority": AUTHORITY, "scope_name": scope,
+        "comparison_profile": PROFILE, "execution_host": "192.168.99.20", "pair_count": pair_count,
+        "column_count": 3519, "column_method_row_count": column_method_count,
+        "numeric_row_count": len(additions), "methods": list(methods), "timing_policy": acceptance["timing"],
+        "acceptance": {"file": accept_name, "sha256": acceptance_sha},
+        "overlay_receipt_sha256": sha(overlay / "OVERLAY_RECEIPT.json"),
+        "source_bindings_sha256": sha(overlay / "SOURCE_BINDINGS.json"), "historical_variants_preserved": True,
+    }
+    data["source"].setdefault("measurement_runs", []).append(run)
+    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[f"cpp135_remaining6_{scope}"] = run
+    write_json(output / "data.json", data)
+    subprocess.run([sys.executable, str(output / "build_ui_payload.py")], cwd=output, check=True, capture_output=True, text=True)
+    new_ui = read_json(output / "ui-data.json")
+    old_ui = read_json(baseline / "ui-data.json")
+    req(new_ui["source_data_sha256"] == sha(output / "data.json"), "UI source SHA differs")
+    req(len(new_ui["compact_records"]) == len(data["dataset_results"]), "UI/data row count differs")
+
+    old_side = read_gzip_json(baseline / "cpp-latest-view-main26.json.gz")
+    old_decoded, new_decoded = B.decoded(old_ui), B.decoded(new_ui)
+    selected = B.retain_unaffected_selected(old_side["cpp"]["selected_rows"], old_decoded, targets)
+    selected.sort(key=lambda row: row["raw_compact_index"])
+    retained_selected_sha = canonical_sha(selected)
+    by_scope = {(row["dataset"], row["family"], row["scope"]): index for index, row in enumerate(additions, old_count)}
+    req(len(by_scope) == len(additions), "duplicate addition identities")
+    for key, index in sorted(by_scope.items()):
+        row = new_decoded[index]
+        req((row["dataset"], row["family"], row["scope"]) == key, "compact append identity differs")
+        selected.append({"raw_compact_index": index, "canonical_family": key[1], "source_family": key[1], "source_comparison_profile": PROFILE, "source_runtime": row["runtime"], "source_host": "192.168.99.20", "authority": AUTHORITY, "pair_status": "numeric", "timing_admitted": True, "measurement_status": row["measurement_status"], "timing_profile_status": row["timing_profile_status"]})
+    prior = {(row["dataset"], row["canonical_family"]): row for row in old_side["cpp"]["pair_ledger"]}
+    req(targets <= set(prior), "target pair absent from baseline ledger")
+    ledger = [copy.deepcopy(row) for key, row in prior.items() if key not in targets]
+    ledger.sort(key=lambda row: (row["dataset"], row["canonical_family"]))
+    retained_ledger_sha = canonical_sha(ledger)
+    all_scopes = set(new_ui["record_tables"]["scopes"])
+    for pair in sorted(targets):
+        scopes = sorted(summaries[pair])
+        indices = [by_scope[(pair[0], pair[1], name)] for name in scopes]
+        overall = summaries[pair]["overall"]
+        bins, terms, sources = overall["runtime_binary_sha256_set"], overall["selected_terminal_sha256_set"], overall["source_selection_set"]
+        ledger.append({"dataset": pair[0], "canonical_family": pair[1], "decision": "select_latest_completed_remaining6_server192_remeasurement", "status": "numeric", "source_comparison_profile": PROFILE, "source_hosts": ["192.168.99.20"], "selected_raw_indices": indices, "selected_scopes": scopes, "missing_scopes_tombstoned": sorted(all_scopes - set(scopes)), "recency_rank": 100, "authority": AUTHORITY, "reason": "Completed server192 full-column remeasurement with built-in exact complete-Block checks; legacy variants remain in history.", "acceptance_sha256": acceptance_sha, "source_selection": sources[0] if len(sources) == 1 else None, "source_selection_set": sources, "runtime_binary_sha256": bins[0] if len(bins) == 1 else None, "runtime_binary_sha256_set": bins, "selected_terminal_sha256": terms[0] if len(terms) == 1 else None, "selected_terminal_sha256_set": terms, "typed_route_contract_sha256": overall["typed_route_contract_sha256"], "scope_support_states": {name: "numeric" for name in scopes}, "variant_status": "uniform_server192_full_dataset_remeasurement"})
+    selected.sort(key=lambda row: row["raw_compact_index"])
+    ledger.sort(key=lambda row: (row["dataset"], row["canonical_family"]))
+    req(len({row["raw_compact_index"] for row in selected}) == len(selected), "duplicate selected compact index")
+    req(canonical_sha([row for row in selected if row["raw_compact_index"] < old_count]) == retained_selected_sha, "unaffected selected rows changed")
+    req(canonical_sha([row for row in ledger if (row["dataset"], row["canonical_family"]) not in targets]) == retained_ledger_sha, "unaffected ledger changed")
+    active = set(old_side["cpp"]["active_native85_families"])
+    active_ledger = [row for row in ledger if row["canonical_family"] in active]
+    req(len(active_ledger) == 164 * 85, "active ledger size differs")
+    status_counts = Counter(row["status"] for row in active_ledger)
+    timing_indices = [row["raw_compact_index"] for row in selected if row["timing_admitted"]]
+    scope_dataset_counts, scope_pair_counts = {}, {}
+    for name in sorted(all_scopes):
+        pairs = []
+        for item in selected:
+            row = new_decoded[item["raw_compact_index"]]
+            if row["scope"] == name:
+                pairs.append((row["dataset"], item["canonical_family"]))
+        scope_dataset_counts[name] = len({pair[0] for pair in pairs})
+        scope_pair_counts[name] = len(set(pairs))
+    side = copy.deepcopy(old_side)
+    side["status"] = new_status
+    side["baseline"] = {"revision": PARENT_HEAD, "ui_data_path": ui_gz_name, "ui_data_sha256": sha(output / "ui-data.json"), "data_path": "data.json", "data_sha256": sha(output / "data.json"), "compact_record_count": len(new_decoded), "parent_published_payload": {"revision": PARENT_HEAD, "data_uncompressed_sha256": old_side["baseline"]["data_sha256"], "ui_data_sha256": old_side["baseline"]["ui_data_sha256"], "cpp_latest_view_uncompressed_sha256": gzip_content_sha(baseline / "cpp-latest-view-main26.json.gz")}}
+    side["identity_contract"]["atomicity"] = f"One newest authority wins per dataset and canonical C++ family; exactly {pair_count} completed server192 decisions in {scope} replace prior latest rows while preserving history."
+    side["precedence"].append({"rank": 100, "authority": AUTHORITY, "scope": f"{pair_count} completed remaining-six server192 decisions ({scope}) on the frozen 135-dataset scope"})
+    side["receipts"][accept_name] = {"path": accept_name, "sha256": acceptance_sha, "schema": acceptance["schema"], "status": acceptance["status"]}
+    side["cpp"]["selected_rows"] = selected
+    side["cpp"]["pair_ledger"] = ledger
+    side["cpp"]["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(selected), timing_admitted_selected_row_count=len(timing_indices), scope_numeric_dataset_counts=scope_dataset_counts, scope_numeric_pair_counts=scope_pair_counts, remaining6_scope=scope, remaining6_pair_count=pair_count, remaining6_numeric_scope_row_count=len(additions))
+    side["cpp"]["timing_subset"] = {"contract": "Row-local admitted timing; replaced families use one server-192 W1/R3/T1 column-mean contract with exact complete-Block checks.", "selected_raw_indices": timing_indices, "selected_row_count": len(timing_indices), "source_profile_counts": dict(sorted(Counter(new_decoded[row["raw_compact_index"]]["comparison_profile"] for row in selected if row["timing_admitted"]).items()))}
+    side["warnings"].append(f"{', '.join(methods)} latest rows use one server192 W1/R3/T1 contract; historical rows remain append-only.")
+    write_json(output / "cpp-latest-view.json", side)
+    deterministic_gzip_bytes((output / "ui-data.json").read_bytes(), output / ui_gz_name)
+    deterministic_gzip_bytes((output / "cpp-latest-view.json").read_bytes(), output / side_gz_name)
+    ui_sha, ui_gz_sha = sha(output / "ui-data.json"), sha(output / ui_gz_name)
+    side_sha, side_gz_sha = sha(output / "cpp-latest-view.json"), sha(output / side_gz_name)
+
+    app_path = output / "app.js"
+    app = app_path.read_text()
+    app = replace_once(app, "const UI_DATA_SHA256='ffd11d5c9a863ca412948c6936b4058b46db9f01f48b738ec0b81ef19bf3f1e6';", f"const UI_DATA_SHA256='{ui_sha}';", "UI canonical SHA")
+    app = replace_once(app, "const UI_DATA_GZIP_SHA256='f16a98d8d4438186dfa9a7ebb196f46069b0f722cdb430b1673fb69c8284bbc3';", f"const UI_DATA_GZIP_SHA256='{ui_gz_sha}';", "UI gzip SHA")
+    app = replace_once(app, "const CPP_LATEST_VIEW_SHA256='6ab4cc1e9e788f5baac4d79a8584ff647e3a6d7451d57a8a1fc1943502b7b2b7';", f"const CPP_LATEST_VIEW_SHA256='{side_sha}';", "sidecar canonical SHA")
+    app = replace_once(app, "const CPP_LATEST_VIEW_GZIP_SHA256='d1c5cb49a446958a4c89310af31fb0c08d8d810cecc97933ca0f51636b3edf13';", f"const CPP_LATEST_VIEW_GZIP_SHA256='{side_gz_sha}';", "sidecar gzip SHA")
+    app = replace_once(app, OLD_STATUS, new_status, "sidecar status guard")
+    app = replace_once(app, "./ui-data-uniform675.json.gz?v=20261016-uniform-five675-transport-v2", f"./{ui_gz_name}?v={version}", "UI fetch")
+    app = replace_once(app, "./cpp-latest-view-main26.json.gz?v=20261015-uniform-five675-v1", f"./{side_gz_name}?v={version}", "sidecar fetch")
+    app_path.write_text(app)
+    subprocess.run(["node", "--check", str(app_path)], check=True)
+    req(sha(output / "ranking.js") == BASELINE_SHA256["ranking.js"], "ranking.js changed")
+
+    index_path = output / "index.html"
+    index = index_path.read_text()
+    index = replace_once(index, "app.js?v=20261015-uniform-five675-v1", f"app.js?v={version}", "app cache token")
+    download_old = '<a href="data-main26.json.br" download>Result snapshot (JSON.BR)</a>'
+    download_new = f'<a href="data-main26.json.br" download>Base result snapshot (JSON.BR)</a> · <a href="{names["DATASET_METHOD_RESULTS.jsonl.gz"]}" download>Latest C++ timing overlay (JSONL.GZ)</a>'
+    index = replace_once(index, download_old, download_new, "provenance download")
+    index_path.write_text(index)
+
+    qa_rows = []
+    tables = new_ui["record_tables"]
+    target_set = set(methods)
+    for family in sorted(target_set):
+        values = []
+        for item in selected:
+            raw = new_ui["compact_records"][item["raw_compact_index"]]
+            if item["canonical_family"] == family and tables["scopes"][raw[1]] == "overall" and tables["comparison_profiles"][raw[3]] == PROFILE:
+                values.append({"dataset": tables["datasets"][raw[0]], "timing_admitted": item["timing_admitted"], "compression_time": raw[7], "decompression_time": raw[8], "profile": tables["comparison_profiles"][raw[3]], "host": item["source_host"]})
+        timed = [row for row in values if row["timing_admitted"] and isinstance(row["compression_time"], (int, float)) and isinstance(row["decompression_time"], (int, float))]
+        qa_rows.append({"family": family, "rate_coverage": len({row["dataset"] for row in values}), "timing_coverage": len({row["dataset"] for row in timed}), "profiles": sorted({row["profile"] for row in timed}), "hosts": sorted({row["host"] for row in timed})})
+    req(len(qa_rows) == len(methods) and all(row["rate_coverage"] == row["timing_coverage"] == 135 and row["profiles"] == [PROFILE] and row["hosts"] == ["192.168.99.20"] for row in qa_rows), "target coverage/timing QA failed")
+    qa = {"schema": "cpp135-remaining6-incremental-candidate-qa-v1", "status": "passed", "parent_revision": PARENT_HEAD, "scope_name": scope, "target_methods": qa_rows, "pair_ledger_count": len(ledger), "selected_row_count": len(selected), "unaffected_selected_rows_preserved": True, "unaffected_pair_ledger_preserved": True, "ranking_unchanged": True}
+    write_json(output / qa_name, qa)
+
+    manifest = read_json(output / "manifest.json")
+    manifest["measurement_runs"] = data["source"]["measurement_runs"]
+    manifest["counts"] = coverage
+    manifest[f"cpp135_remaining6_{scope}"] = {**run, "public_evidence": public, "acceptance": {"file": accept_name, "sha256": acceptance_sha}, "candidate_qa": {"file": qa_name, "sha256": sha(output / qa_name)}, "builder": {"file": Path(__file__).name, "sha256": sha(Path(__file__))}}
+    manifest["latest_page_inputs"] = {"compact_data": {"encoding": "gzip", "file": ui_gz_name, "sha256": ui_gz_sha, "uncompressed_sha256": ui_sha}, "selection_sidecar": {"encoding": "gzip", "file": side_gz_name, "sha256": side_gz_sha, "uncompressed_sha256": side_sha, "schema": side["schema"], "status": side["status"]}}
+    manifest["cpp_latest_view"] = copy.deepcopy(manifest["latest_page_inputs"]["selection_sidecar"])
+    manifest["incremental_scientific_snapshot"] = {"schema": "compressionbenchmark-base-plus-overlay-v1", "base_revision": PARENT_HEAD, "base_full_file": "data-main26.json.br", "base_full_uncompressed_sha256": old_side["baseline"]["data_sha256"], "overlay_file": names["DATASET_METHOD_RESULTS.jsonl.gz"], "overlay_sha256": public[names["DATASET_METHOD_RESULTS.jsonl.gz"]]["sha256"], "derived_full_uncompressed_sha256": sha(output / "data.json"), "derived_full_row_count": len(data["dataset_results"]), "replay_builder": Path(__file__).name, "note": "The large full snapshot is deterministically derived locally and omitted from publication storage; the live page reads the SHA-bound compact snapshot and sidecar."}
+    write_json(output / "manifest.json", manifest)
+    shutil.copy2(Path(__file__), output / Path(__file__).name)
+
+    publication_files = ["app.js", "index.html", "manifest.json", ui_gz_name, side_gz_name, *public.keys(), accept_name, qa_name, Path(__file__).name]
+    integration = {
+        "schema": "compressionbenchmark-cpp135-remaining6-incremental-integration-v1", "status": "passed_not_published",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(), "parent_revision": PARENT_HEAD, "scope_name": scope,
+        "authority": AUTHORITY, "historical_dataset_result_count": old_count, "historical_dataset_results_canonical_sha256": old_rows_sha,
+        "new_dataset_result_count": len(additions), "final_dataset_result_count": len(data["dataset_results"]),
+        "scope": {"pair_count": pair_count, "methods": list(methods), "column_count": 3519, "column_method_row_count": column_method_count, "numeric_scope_rows": len(additions)},
+        "overlay": {"receipt_sha256": sha(overlay / "OVERLAY_RECEIPT.json"), "source_bindings_sha256": sha(overlay / "SOURCE_BINDINGS.json"), "column_results_sha256": sha(overlay / "COLUMN_RESULTS.jsonl.gz"), "dataset_method_results_sha256": sha(overlay / "DATASET_METHOD_RESULTS.jsonl.gz")},
+        "canonical_snapshot": {"base_revision": PARENT_HEAD, "base_data_sha256": old_side["baseline"]["data_sha256"], "derived_data_sha256": sha(output / "data.json"), "derived_ui_sha256": ui_sha, "derived_sidecar_sha256": side_sha},
+        "publication_files_excluding_this_receipt": {name: {"bytes": (output / name).stat().st_size, "sha256": sha(output / name)} for name in publication_files},
+        "publication_file_list": publication_files + [integration_name],
+        "publication_total_bytes_excluding_this_receipt": sum((output / name).stat().st_size for name in publication_files),
+        "semantic_checks": {"only_target_pairs_replaced": True, "historical_rows_retained": True, "unaffected_selected_rows_preserved": True, "unaffected_pair_ledger_preserved": True, "same_host_w1_r3_t1": True, "target_methods_each_cover_135_datasets": True, "target_methods_no_mixed_timing_identity": True, "built_in_exact_block_bound": True, "ranking_unchanged": True, "base_plus_overlay_hash_closure": True, "live_ui_sidecar_hash_closure": True},
+    }
+    write_json(output / integration_name, integration)
+    print(json.dumps({"status": integration["status"], "scope": scope, "output": str(output), "pair_count": pair_count, "methods": list(methods), "numeric_rows_added": len(additions), "publication_total_bytes": integration["publication_total_bytes_excluding_this_receipt"] + (output / integration_name).stat().st_size, "integration_sha256": sha(output / integration_name), "publication_files": integration["publication_file_list"]}, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

cpp-latest-view-remaining6-completed5-patch.json.gz

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

data-remaining6-completed5.json.br

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

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-uniform-five675-v1" type="module"></script>
+  <script src="app.js?v=20261016-remaining6-completed5-incremental-v3" 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-main26.json.br" download>Result snapshot (JSON.BR)</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-remaining6-completed5.json.br" download>Latest full result snapshot (JSON.BR)</a> · <a href="remaining6-completed5-dataset-method-overlay.jsonl.gz" download>Latest C++ timing overlay (JSONL.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-main26.json.br">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-remaining6-completed5.json.br">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": 6349,
+    "configuration_aggregate_row_count": 6376,
     "corrected_five425": {
       "active_method_count": 85,
       "all_na_pair_count": 0,
@@ -182,6 +182,39 @@
         "threads": 1
       }
     },
+    "cpp135_remaining6_completed5": {
+      "acceptance": {
+        "file": "REMAINING6_COMPLETED5_ACCEPTANCE.json",
+        "sha256": "5940179bc7fa1b43c0db86efb063f8e7c40b6b5ddd6ba07bcfc9893f990acae3"
+      },
+      "authority": "cpp135_remaining_six_server192_latest",
+      "column_count": 3519,
+      "column_method_row_count": 17595,
+      "comparison_profile": "cpp-native192-remaining-six135-whole-column-20261016-v1",
+      "execution_host": "192.168.99.20",
+      "historical_variants_preserved": true,
+      "methods": [
+        "Crush",
+        "Density",
+        "Gipfeli",
+        "LZO2A",
+        "Lzlib"
+      ],
+      "numeric_row_count": 1565,
+      "overlay_receipt_sha256": "70a8782c0324ec29f48c478ba1aa35c922b84194335af48a912911435895532e",
+      "pair_count": 675,
+      "schema": "cpp135-remaining6-site-import-v1",
+      "scope_name": "completed5",
+      "source_bindings_sha256": "7a63cd921cee63e53de4a74f21c38c154ff3073eeb81d42a12be79241305ba2b",
+      "timing_policy": {
+        "aggregation": "equal-column mean of median(aligned block sums)/valid native points",
+        "comparison_profile": "cpp-native192-remaining-six135-whole-column-20261016-v1",
+        "cross_host_mixing": false,
+        "host": "192.168.99.20",
+        "schedule": "one warmup; three encode measurements; then three decode measurements",
+        "threads": 1
+      }
+    },
     "cpp135_uniform_five675": {
       "acceptance": {
         "file": "UNIFORM_FIVE675_ACCEPTANCE.json",
@@ -215,7 +248,7 @@
       }
     },
     "dataset_count": 164,
-    "dataset_result_row_count": 105174,
+    "dataset_result_row_count": 106739,
     "excluded_datasets": [
       "Arade",
       "app_flow",
@@ -227,7 +260,7 @@
       "tiktok_trending_hashtags_music",
       "youtube_trending_2019_2020"
     ],
-    "family_best_aggregate_row_count": 2027,
+    "family_best_aggregate_row_count": 2042,
     "float_scaling9": {
       "acceptance": {
         "file": "FLOAT_SCALING9_SITE_ACCEPTANCE.json",
@@ -251,7 +284,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": 1338,
+    "method_configuration_count": 1347,
     "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,
@@ -550,8 +583,8 @@
     "native86_unresolved_problem_pair_count": 0,
     "native86_v9_recovered_pair_count": 154,
     "paper_leaderboard_row_count": 0,
-    "runtime_configuration_count": 1986,
-    "runtime_count": 15,
+    "runtime_configuration_count": 1995,
+    "runtime_count": 16,
     "runtimes": [
       "cpp",
       "cpp-native166-corrected-five-20261012-v1",
@@ -565,6 +598,7 @@
       "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",
+      "cpp-native192-remaining-six135-whole-column-20261016-v1",
       "cpp-native192-uniform-five135-whole-column-20261015-v1",
       "java",
       "python"
@@ -809,6 +843,61 @@
       "threads": 1
     }
   },
+  "cpp135_remaining6_completed5": {
+    "acceptance": {
+      "file": "REMAINING6_COMPLETED5_ACCEPTANCE.json",
+      "sha256": "5940179bc7fa1b43c0db86efb063f8e7c40b6b5ddd6ba07bcfc9893f990acae3"
+    },
+    "authority": "cpp135_remaining_six_server192_latest",
+    "builder": {
+      "file": "build_remaining6_incremental_site.py",
+      "sha256": "358404633f9652ab2744c64e63b2c4679d8c03674cf30a9faf4c9809f557c8e1"
+    },
+    "candidate_qa": {
+      "file": "REMAINING6_COMPLETED5_CANDIDATE_QA.json",
+      "sha256": "8ef90c549de5a28ff56e969dc29e5e9d7ff1953556222de4b0fa8ad7f8355ad4"
+    },
+    "column_count": 3519,
+    "column_method_row_count": 17595,
+    "comparison_profile": "cpp-native192-remaining-six135-whole-column-20261016-v1",
+    "execution_host": "192.168.99.20",
+    "historical_variants_preserved": true,
+    "methods": [
+      "Crush",
+      "Density",
+      "Gipfeli",
+      "LZO2A",
+      "Lzlib"
+    ],
+    "numeric_row_count": 1565,
+    "overlay_receipt_sha256": "70a8782c0324ec29f48c478ba1aa35c922b84194335af48a912911435895532e",
+    "pair_count": 675,
+    "public_evidence": {
+      "REMAINING6_COMPLETED5_OVERLAY_RECEIPT.json": {
+        "bytes": 1001,
+        "sha256": "70a8782c0324ec29f48c478ba1aa35c922b84194335af48a912911435895532e"
+      },
+      "REMAINING6_COMPLETED5_SOURCE_BINDINGS.json": {
+        "bytes": 1246,
+        "sha256": "7a63cd921cee63e53de4a74f21c38c154ff3073eeb81d42a12be79241305ba2b"
+      },
+      "remaining6-completed5-dataset-method-overlay.jsonl.gz": {
+        "bytes": 140763,
+        "sha256": "9ec315718182471c54eab9af11d9ddeac66fb08f23fb136ffd727816f495d6b8"
+      }
+    },
+    "schema": "cpp135-remaining6-site-import-v1",
+    "scope_name": "completed5",
+    "source_bindings_sha256": "7a63cd921cee63e53de4a74f21c38c154ff3073eeb81d42a12be79241305ba2b",
+    "timing_policy": {
+      "aggregation": "equal-column mean of median(aligned block sums)/valid native points",
+      "comparison_profile": "cpp-native192-remaining-six135-whole-column-20261016-v1",
+      "cross_host_mixing": false,
+      "host": "192.168.99.20",
+      "schedule": "one warmup; three encode measurements; then three decode measurements",
+      "threads": 1
+    }
+  },
   "cpp135_uniform_five675": {
     "acceptance": {
       "file": "UNIFORM_FIVE675_ACCEPTANCE.json",
@@ -865,22 +954,22 @@
   },
   "cpp_latest_view": {
     "encoding": "gzip",
-    "file": "cpp-latest-view-main26.json.gz",
+    "file": "cpp-latest-view-remaining6-completed5.json.gz",
     "schema": "compressionbenchmark-cpp-latest-view-v1",
-    "sha256": "d1c5cb49a446958a4c89310af31fb0c08d8d810cecc97933ca0f51636b3edf13",
-    "status": "built_from_published_lossless270_plus_completed_uniform_five675",
-    "uncompressed_sha256": "6ab4cc1e9e788f5baac4d79a8584ff647e3a6d7451d57a8a1fc1943502b7b2b7"
+    "sha256": "dc03363557cabbc83b2e2020d4c5972590fd27f81edde08dc2ac62b4a37238e6",
+    "status": "built_from_published_lossless270_plus_completed_uniform_five675_plus_completed_remaining6_completed5",
+    "uncompressed_sha256": "29499dcee2681cd97ec27326dc3fcb321c77b1a165d9f829f5e27a6d7d2ebd9b"
   },
-  "data_file": "data-main26.json.br",
-  "data_sha256": "bc1c5c8503282683a78505a9baa1ffd60a28aa8421f8f5ecf8c8c13012853c39",
+  "data_file": "data-remaining6-completed5.json.br",
+  "data_sha256": "892caa7075806b231913c7414c5774e26458ca9b7acf784f27a7eefac77cae8e",
   "data_transport": {
     "encoding": "br",
-    "file": "data-main26.json.br",
-    "quality": 6,
-    "sha256": "bc1c5c8503282683a78505a9baa1ffd60a28aa8421f8f5ecf8c8c13012853c39",
-    "uncompressed_sha256": "5c20e191e146d02408f4d7fc41224e8e72b81bd18bf862f3dbda1708d44706f8"
+    "file": "data-remaining6-completed5.json.br",
+    "quality": 10,
+    "sha256": "892caa7075806b231913c7414c5774e26458ca9b7acf784f27a7eefac77cae8e",
+    "uncompressed_sha256": "a0e8b3c6207e627fe9c863a968af52257750f6c33becd231201803bc80f1c184"
   },
-  "data_uncompressed_sha256": "5c20e191e146d02408f4d7fc41224e8e72b81bd18bf862f3dbda1708d44706f8",
+  "data_uncompressed_sha256": "a0e8b3c6207e627fe9c863a968af52257750f6c33becd231201803bc80f1c184",
   "dataset_catalog_sha256": "47869c8078e8c864810d4f961fa5879e120943bb3f371b39f0adc74f3de2ee2d",
   "excluded_content": [
     "raw datasets",
@@ -922,20 +1011,47 @@
       "status": "preserved_historical_not_read_by_latest_page"
     }
   },
+  "incremental_scientific_snapshot": {
+    "base_full_file": "data-main26.json.br",
+    "base_full_uncompressed_sha256": "5c20e191e146d02408f4d7fc41224e8e72b81bd18bf862f3dbda1708d44706f8",
+    "base_revision": "a667e581961f786940c9e1c59172e6057db72600",
+    "derived_full_row_count": 106739,
+    "derived_full_uncompressed_sha256": "a0e8b3c6207e627fe9c863a968af52257750f6c33becd231201803bc80f1c184",
+    "live_sidecar_patch_file": "cpp-latest-view-remaining6-completed5-patch.json.gz",
+    "live_ui_patch_file": "ui-data-remaining6-completed5-patch.json.gz",
+    "note": "The large full snapshot is deterministically derived locally and omitted from publication storage; the live page reads the SHA-bound compact snapshot and sidecar.",
+    "overlay_file": "remaining6-completed5-dataset-method-overlay.jsonl.gz",
+    "overlay_sha256": "9ec315718182471c54eab9af11d9ddeac66fb08f23fb136ffd727816f495d6b8",
+    "published_full_file": "data-remaining6-completed5.json.br",
+    "published_full_sha256": "892caa7075806b231913c7414c5774e26458ca9b7acf784f27a7eefac77cae8e",
+    "published_full_uncompressed_sha256": "a0e8b3c6207e627fe9c863a968af52257750f6c33becd231201803bc80f1c184",
+    "replay_builder": "build_remaining6_incremental_site.py",
+    "schema": "compressionbenchmark-base-plus-overlay-v1"
+  },
   "latest_page_inputs": {
-    "compact_data": {
+    "base_compact_data": {
       "encoding": "gzip",
       "file": "ui-data-uniform675.json.gz",
       "sha256": "f16a98d8d4438186dfa9a7ebb196f46069b0f722cdb430b1673fb69c8284bbc3",
       "uncompressed_sha256": "ffd11d5c9a863ca412948c6936b4058b46db9f01f48b738ec0b81ef19bf3f1e6"
     },
-    "selection_sidecar": {
+    "base_selection_sidecar": {
       "encoding": "gzip",
       "file": "cpp-latest-view-main26.json.gz",
-      "schema": "compressionbenchmark-cpp-latest-view-v1",
       "sha256": "d1c5cb49a446958a4c89310af31fb0c08d8d810cecc97933ca0f51636b3edf13",
-      "status": "built_from_published_lossless270_plus_completed_uniform_five675",
       "uncompressed_sha256": "6ab4cc1e9e788f5baac4d79a8584ff647e3a6d7451d57a8a1fc1943502b7b2b7"
+    },
+    "selection_incremental_patch": {
+      "encoding": "gzip",
+      "file": "cpp-latest-view-remaining6-completed5-patch.json.gz",
+      "sha256": "c54b1ad640406637120e3b273002f35e125f4390dc393f3ac21aff29c0ec7f63",
+      "uncompressed_sha256": "8e98c21986c4a7ca79b6af19d92fcb923d26ad314e2857d900f9906fc13463f6"
+    },
+    "ui_incremental_patch": {
+      "encoding": "gzip",
+      "file": "ui-data-remaining6-completed5-patch.json.gz",
+      "sha256": "5169074c3097d131ffbc550ac1466e719e65f8e7ae630dedbec352b5ce16bca3",
+      "uncompressed_sha256": "66dbd2505522c16bd996bf4dabfc7afdd64fadf15e9307bf16230960ab1591e5"
     }
   },
   "measurement_runs": [
@@ -1697,6 +1813,39 @@
         "schedule": "one warmup; three encode measurements; then three decode measurements",
         "threads": 1
       }
+    },
+    {
+      "acceptance": {
+        "file": "REMAINING6_COMPLETED5_ACCEPTANCE.json",
+        "sha256": "5940179bc7fa1b43c0db86efb063f8e7c40b6b5ddd6ba07bcfc9893f990acae3"
+      },
+      "authority": "cpp135_remaining_six_server192_latest",
+      "column_count": 3519,
+      "column_method_row_count": 17595,
+      "comparison_profile": "cpp-native192-remaining-six135-whole-column-20261016-v1",
+      "execution_host": "192.168.99.20",
+      "historical_variants_preserved": true,
+      "methods": [
+        "Crush",
+        "Density",
+        "Gipfeli",
+        "LZO2A",
+        "Lzlib"
+      ],
+      "numeric_row_count": 1565,
+      "overlay_receipt_sha256": "70a8782c0324ec29f48c478ba1aa35c922b84194335af48a912911435895532e",
+      "pair_count": 675,
+      "schema": "cpp135-remaining6-site-import-v1",
+      "scope_name": "completed5",
+      "source_bindings_sha256": "7a63cd921cee63e53de4a74f21c38c154ff3073eeb81d42a12be79241305ba2b",
+      "timing_policy": {
+        "aggregation": "equal-column mean of median(aligned block sums)/valid native points",
+        "comparison_profile": "cpp-native192-remaining-six135-whole-column-20261016-v1",
+        "cross_host_mixing": false,
+        "host": "192.168.99.20",
+        "schedule": "one warmup; three encode measurements; then three decode measurements",
+        "threads": 1
+      }
     }
   ],
   "native86_imports": {

remaining6-completed5-dataset-method-overlay.jsonl.gz

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

ui-data-remaining6-completed5-patch.json.gz

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