Complete 1688 lossless C++ results across the current 135 datasets

Import 89 completed integer-method DSC2/2DIFF repairs and 1599 completed native typed-adapter pairs. Preserve all historical measurements, original dtype and missing bitmap, complete frame bytes and W1/R3/T1 timings. The current C++ view now has 83 of 85 methods with full 135-dataset numeric coverage. BUFF/CORAD lossless improvements and 383 native timing supplements remain separate pending campaigns. Server166 current v5 is synchronized.

.gitattributes

@@ -37,3 +37,4 @@ data.json filter=lfs diff=lfs merge=lfs -text
 dbp-audit-columns.csv filter=lfs diff=lfs merge=lfs -text
 dbp-audit.json filter=lfs diff=lfs merge=lfs -text
 cpp-latest-view.json filter=lfs diff=lfs merge=lfs -text
+ui-data.json filter=lfs diff=lfs merge=lfs -text

INTEGER89_OVERLAY_RECEIPT.json

@@ -0,0 +1,36 @@
+{
+  "created_epoch_ns": 1792074441564770443,
+  "dataset_count": 17,
+  "dataset_method_count": 89,
+  "files": {
+    "COLUMN_AUDIT.jsonl.gz": {
+      "bytes": 248060,
+      "sha256": "2deedeba545c7ea606f3a02441d8d1401203e817c1f63f53f3532d0aa575a49b"
+    },
+    "COLUMN_RESULTS.jsonl.gz": {
+      "bytes": 495805,
+      "sha256": "3f938e29eae57258d9c74798cbc770ee08563f6b36f85d9947d5e7b1d6a70f6e"
+    },
+    "DATASET_METHOD_RESULTS.jsonl.gz": {
+      "bytes": 17646,
+      "sha256": "a302881e785f537a7394261cd404bc3a72c9a575e82afadeb5b823346f5c08c7"
+    },
+    "RETAINED_INTEGER_COLUMNS.jsonl.gz": {
+      "bytes": 123028,
+      "sha256": "b1b4e1682464b85fb74dc3d3146a5cf92b6d9d1038e452c13c91922f62d64b1d"
+    },
+    "SOURCE_BINDINGS.json": {
+      "bytes": 5913,
+      "sha256": "9c045d5ae0bc5ad948f343c1d438245858fe568705c1c1bd3569a75524e4dddd"
+    }
+  },
+  "method_count": 7,
+  "replacement_float_column_method_count": 2203,
+  "retained_integer_column_method_count": 623,
+  "schema": "cpp135-integer89-overlay-receipt-v1",
+  "status": "complete_verified_not_published",
+  "support_state_counts": {
+    "full_numeric": 89
+  },
+  "timing": "W1/R3/T1; aligned block sums, median; precision charged exactly once per method-column"
+}

INTEGER89_SOURCE_BINDINGS.json

@@ -0,0 +1,87 @@
+{
+  "base_aggregate": {
+    "COLUMN_RESULTS.jsonl.gz": "6c3d693556fb58f8277ac201dfe217ea85aec65489a707260af85981faa21e9b",
+    "DATASET_METHOD_RESULTS.jsonl.gz": "5ba82d79f07327d6a5b2e1405d3f58db7e72930dcd0284132764ff48a8b5859b",
+    "RECEIPT.json": "f098925d8bd0b5718b102a8b6921b1234ced3baec80e2faeb47f2edb71c2d337"
+  },
+  "campaign": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1",
+  "campaign_terminal_sha256": "5fa8878c5f3e8dcc96c3d78edf1f0339d0de984d97a1e89cb2048fe159b12a7b",
+  "job_terminals": [
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/Bar-Crawl__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "cbf85039452fe027f87a18548b549774ae00b80198d42b208dc9eaedec276a6e"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/Romance__2DIFF__float_dsc2_segmented/attempt_0001/TERMINAL.json",
+      "sha256": "928b28c76578e6d2dd89f68f1172aa696dbe93a70a7f59e10930e34254d007d5"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/current_velocity__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "f43cfccd8510bd0f36b1a5a945579d423ae45a6d5bf59babe7ddc1ead445e913"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/eea_pm25_forecasting__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "5e51a249237090b00cab547f1f7b7a0327f9cbee4826c751c2edbc3935f14dbc"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/faang_engineered_time_series_features_2013_2025__2DIFF__float_dsc2_segmented/attempt_0001/TERMINAL.json",
+      "sha256": "78aff1d0b7a66a7737b72b76952f10c90270819d998e10003a77ca4e24cb3690"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/goes_omni_electron_flux_forecasting__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "08c4b758e75bc254301b599bdb81e37b7e7c9e859c46419e2b159cf24bd3f8e7"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/hourly-stock-data-2023__2DIFF__float_dsc2_segmented/attempt_0001/TERMINAL.json",
+      "sha256": "27a312e9c7272d3479e4caf706786ae7f67bd8e302cd1e826e4d0be90aa6ff89"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/kdd_cup_2018__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "ae93f39753d17d65610e7fea51e2cc2950dfb11d9ae28fdecb7137f9b6a41ce4"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/kraken-trading-data__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "4210ce3603b17aae584e17a00b232dadf4c14dfbc7a86e51263e57c201e4c45a"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/multi_model_trading_data__2DIFF__float_dsc2_segmented/attempt_0001/TERMINAL.json",
+      "sha256": "8237c76835d17537eef5de2ebf7cd3af0542629d43b6e90b0caebebe05c4be1d"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/ooni_censorship_historical__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "8774e733e4d5fb8f933828cbd4b6d945a57c3cd96196aa72bd943a56f5865957"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/orbital_chaos_nasa_ssc__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "0a8c5af7acbcbee27030bfe08f5c1910f20d23499ba93c93cc75bdef5efb9d4c"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/reg_forecasting_v2__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "66e8b487d0c99fba8a79e297ba193af71856ab90a1236078c6ce9762b3019805"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/stock_dataset__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "e155b661e72f4f564f36a3cb17bf82040bc444dc115865d9b81471308327f139"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/timeseries_1mn_stocks__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "4375efaa17f7f6b04e9bab358cee490140c057123934dafdbd197cdada60c3c8"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/tourism_residuals__2DIFF__float_dsc2_segmented/attempt_0001/TERMINAL.json",
+      "sha256": "e2b92439c3c82493b40210ecf381b820ceb154257f8842a68ffd1368970ac5a5"
+    },
+    {
+      "path": "/data/root/web_compression/cpp135_int9_remaining_dsc2_20261015_v1/attempt1/jobs/wind_farms_minutely__2DIFF_DBP_FastPFor_LECO_RLBE_SVB_Simple8b__float_dsc2/attempt_0001/TERMINAL.json",
+      "sha256": "cec2f17db0dfa5eddda2fab0e4a165184d2ef4d7729663f5881bf3c41b9d2e2e"
+    }
+  ],
+  "lossless_proof": "producer required exact Block equality for warmup and each measured decode",
+  "plan_sha256": "31b493b594dc215117889acef869e84f788448044d2dfe8caec6bddcd41f476c",
+  "raw_result_file_count": 355,
+  "raw_result_row_count": 500630,
+  "raw_result_total_bytes": 1933751879,
+  "runtime_binary_sha256": "41ab1a05e8aa4a77a3048cf696952902b1e4ddd67a69e6ef613a181821a43a20",
+  "schema": "cpp135-integer89-source-bindings-v1",
+  "status": "frozen_completed_overlay"
+}

LOSSLESS_COMPLETION_1688_ACCEPTANCE.json

@@ -0,0 +1,52 @@
+{
+  "created_at": "2026-10-15T14:37:03.293905+00:00",
+  "lossless": "producer required exact complete original Block equality after warmup and every measured decode",
+  "overlay_receipts": {
+    "integer89": "9c73de8af669b141f87acceebb11c9aba1a707a5af80cf55064f010fbddad338",
+    "native15": "6dc3eeeb2d435a7bab52ae803bca3241971ac0727159ae6b88c9693c7bf2ef1e"
+  },
+  "parent_revision": "3e03c82b1f7873db19ccbc0bf0f093fd02375a9f",
+  "public_evidence": {
+    "INTEGER89_OVERLAY_RECEIPT.json": {
+      "bytes": 1229,
+      "sha256": "9c73de8af669b141f87acceebb11c9aba1a707a5af80cf55064f010fbddad338"
+    },
+    "INTEGER89_SOURCE_BINDINGS.json": {
+      "bytes": 5913,
+      "sha256": "9c045d5ae0bc5ad948f343c1d438245858fe568705c1c1bd3569a75524e4dddd"
+    },
+    "NATIVE15_OVERLAY_RECEIPT.json": {
+      "bytes": 1119,
+      "sha256": "6dc3eeeb2d435a7bab52ae803bca3241971ac0727159ae6b88c9693c7bf2ef1e"
+    },
+    "NATIVE15_SOURCE_BINDINGS.json": {
+      "bytes": 644095,
+      "sha256": "3904277d13d9ad3abf0abacd273967b5137f193214834b17bcbb080cb0d831eb"
+    },
+    "integer89-dataset-method-overlay.jsonl.gz": {
+      "bytes": 17646,
+      "sha256": "a302881e785f537a7394261cd404bc3a72c9a575e82afadeb5b823346f5c08c7"
+    },
+    "native15-dataset-method-overlay.jsonl.gz": {
+      "bytes": 846187,
+      "sha256": "827c61cadd7ade050b1992c28ebaa3bc5be27faaa0fb92c2b0c38ed1b6d2b33e"
+    }
+  },
+  "schema": "compressionbenchmark-cpp135-lossless-completion-1688-acceptance-v1",
+  "scope": {
+    "dataset_count": 135,
+    "integer89_pair_count": 89,
+    "method_count": 22,
+    "native15_pair_count": 1599,
+    "pair_count": 1688
+  },
+  "status": "accepted_completed_builtin_bitexact",
+  "timing": {
+    "aggregation": "equal-column mean of median(aligned block sums)/valid native points",
+    "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+    "cross_host_mixing": false,
+    "host": "192.168.99.20",
+    "schedule": "one warmup; three encode measurements; then three decode measurements",
+    "threads": 1
+  }
+}

LOSSLESS_COMPLETION_1688_INTEGRATION.json

@@ -0,0 +1,111 @@
+{
+  "created_at": "2026-10-15T14:37:16.859103+00:00",
+  "files": {
+    "INTEGER89_OVERLAY_RECEIPT.json": {
+      "bytes": 1229,
+      "sha256": "9c73de8af669b141f87acceebb11c9aba1a707a5af80cf55064f010fbddad338"
+    },
+    "INTEGER89_SOURCE_BINDINGS.json": {
+      "bytes": 5913,
+      "sha256": "9c045d5ae0bc5ad948f343c1d438245858fe568705c1c1bd3569a75524e4dddd"
+    },
+    "LOSSLESS_COMPLETION_1688_ACCEPTANCE.json": {
+      "bytes": 2027,
+      "sha256": "30f6ada7bfde981151b9a7c2ee66644146ba602cca135411eb72d8bb48bca982"
+    },
+    "NATIVE15_OVERLAY_RECEIPT.json": {
+      "bytes": 1119,
+      "sha256": "6dc3eeeb2d435a7bab52ae803bca3241971ac0727159ae6b88c9693c7bf2ef1e"
+    },
+    "NATIVE15_SOURCE_BINDINGS.json": {
+      "bytes": 644095,
+      "sha256": "3904277d13d9ad3abf0abacd273967b5137f193214834b17bcbb080cb0d831eb"
+    },
+    "README.md": {
+      "bytes": 5090,
+      "sha256": "6d04279b903d1084d35417c933998b09dfa527c9f29aae717d89d3c439748f9b"
+    },
+    "app.js": {
+      "bytes": 69495,
+      "sha256": "ee28d2a2fb3d9efc0e22fe0893c2fb998162fe07e494d810752ab527de764518"
+    },
+    "build_lossless_completion_site.py": {
+      "bytes": 25930,
+      "sha256": "1ab499a9408a9ad40cd1bf3773e9f078b6e4b5abf34d9ada2af295b906f9f13b"
+    },
+    "cpp-latest-view-main26.json.gz": {
+      "bytes": 1678540,
+      "sha256": "78945c2427f6a4f11ebcd9d3b2836b143b6c9b342f4272f05fd0bde1e48b28c7"
+    },
+    "data-main26.json.gz": {
+      "bytes": 14942911,
+      "sha256": "59ed00b27881b407aed705212f51841836295dced5aea0dcd0ca9f028455daa8"
+    },
+    "index.html": {
+      "bytes": 17827,
+      "sha256": "f13cafa2d5c9b5f3b5f5cc2a9c181c527c55aaefba5b1db11bfe58d4ebd02ed2"
+    },
+    "integer89-dataset-method-overlay.jsonl.gz": {
+      "bytes": 17646,
+      "sha256": "a302881e785f537a7394261cd404bc3a72c9a575e82afadeb5b823346f5c08c7"
+    },
+    "manifest.json": {
+      "bytes": 103571,
+      "sha256": "6c13217415168e8bc9536d95c65213fb6a5825917f18cc754c533edc37de180a"
+    },
+    "native15-dataset-method-overlay.jsonl.gz": {
+      "bytes": 846187,
+      "sha256": "827c61cadd7ade050b1992c28ebaa3bc5be27faaa0fb92c2b0c38ed1b6d2b33e"
+    },
+    "ui-data.json": {
+      "bytes": 12492746,
+      "sha256": "f47285cda7d42c6fe4846ebb717669eabe4f80953902f7609e51c912d0d34c30"
+    }
+  },
+  "final_dataset_result_count": 102983,
+  "historical_dataset_result_count": 99068,
+  "historical_dataset_results_canonical_sha256": "ec99dd176ab01a95e0939c6a371ef9aa394bd778cfa8ccc4f6ede11ecf2166a4",
+  "new_dataset_result_count": 3915,
+  "parent_revision": "3e03c82b1f7873db19ccbc0bf0f093fd02375a9f",
+  "publication_file_list": [
+    "data-main26.json.gz",
+    "ui-data.json",
+    "cpp-latest-view-main26.json.gz",
+    "app.js",
+    "index.html",
+    "README.md",
+    "manifest.json",
+    "integer89-dataset-method-overlay.jsonl.gz",
+    "INTEGER89_OVERLAY_RECEIPT.json",
+    "INTEGER89_SOURCE_BINDINGS.json",
+    "native15-dataset-method-overlay.jsonl.gz",
+    "NATIVE15_OVERLAY_RECEIPT.json",
+    "NATIVE15_SOURCE_BINDINGS.json",
+    "LOSSLESS_COMPLETION_1688_ACCEPTANCE.json",
+    "build_lossless_completion_site.py",
+    "LOSSLESS_COMPLETION_1688_INTEGRATION.json"
+  ],
+  "schema": "compressionbenchmark-cpp135-lossless-completion-1688-integration-v1",
+  "scope": {
+    "integer89": 89,
+    "native15": 1599,
+    "numeric_scope_rows": 3915,
+    "pair_count": 1688
+  },
+  "semantic_checks": {
+    "built_in_exact_block_bound": true,
+    "data_ui_sidecar_hash_closure": true,
+    "historical_rows_retained": true,
+    "only_exact_1688_latest_cpp_pair_decisions_replaced": true,
+    "ranking_unchanged": true,
+    "same_host_w1_r3_t1": true,
+    "typed_routes_and_binary_sets_explicit": true
+  },
+  "status": "passed_not_published",
+  "transport": {
+    "data_gzip_sha256": "59ed00b27881b407aed705212f51841836295dced5aea0dcd0ca9f028455daa8",
+    "data_uncompressed_sha256": "71340b992134dacb4dd1dea100218a86585521c3ea03da75098be49af47cc721",
+    "sidecar_gzip_sha256": "78945c2427f6a4f11ebcd9d3b2836b143b6c9b342f4272f05fd0bde1e48b28c7",
+    "sidecar_uncompressed_sha256": "9d0729013696f867d0a007e122eb5d6c55e473da029ab5e5935b6b2bb80c818d"
+  }
+}

NATIVE15_OVERLAY_RECEIPT.json

@@ -0,0 +1,35 @@
+{
+  "created_epoch_ns": 1792074825057751799,
+  "dataset_count": 117,
+  "dataset_method_count": 1599,
+  "files": {
+    "COLUMN_AUDIT.jsonl.gz": {
+      "bytes": 3237710,
+      "sha256": "44bf546dcc8637434b2ea4376364d30a8647162573c602ba42005cd3170da455"
+    },
+    "COLUMN_RESULTS.jsonl.gz": {
+      "bytes": 7567977,
+      "sha256": "53855c7a69eae3f0ed7bd0cd4fd624a537386881ac59245978a03901dad4d30c"
+    },
+    "DATASET_METHOD_RESULTS.jsonl.gz": {
+      "bytes": 846187,
+      "sha256": "827c61cadd7ade050b1992c28ebaa3bc5be27faaa0fb92c2b0c38ed1b6d2b33e"
+    },
+    "RETAINED_COLUMNS.jsonl.gz": {
+      "bytes": 3349754,
+      "sha256": "8de89a78dfee66808d64f5cd5403a69e5d3877ac909c3014a117dd025cd5a2ce"
+    },
+    "SOURCE_BINDINGS.json": {
+      "bytes": 644095,
+      "sha256": "3904277d13d9ad3abf0abacd273967b5137f193214834b17bcbb080cb0d831eb"
+    }
+  },
+  "method_count": 15,
+  "replacement_column_method_count": 27121,
+  "retained_column_method_count": 15963,
+  "schema": "cpp135-native15-overlay-receipt-v1",
+  "status": "complete_verified_not_published",
+  "support_state_counts": {
+    "full_numeric": 1599
+  }
+}

README.md

@@ -26,3 +26,7 @@ The historical `164×85=13,940` terminal matrix remains downloadable and is not
 ## DSC2 BOS/REGER reuse
 
 The latest C++ view additionally replaces exactly 24 formerly partial BOS/REGER pairs over 12 datasets. Repaired float columns use the DSC2 v2 route; successful integer columns retain their Main26 route. All work ran on server 192 under the staged W1/R3/T1 contract (three encode measurements followed by three decode measurements), with precision derived once per float method-column and built-in complete Block bit-exact checks. Composite rows retain every binary, terminal, profile and source route; no scalar binary identity is invented.
+
+## Completed lossless recovery
+
+This release appends 3915 dtype-scope rows and replaces exactly 1,688 latest C++ pair decisions from the completed integer89 and native15 campaigns. All measurements ran on server 192 with W1/R3/T1 and built-in exact complete-Block checks. Historical rows and the prior DSC2 release remain unchanged.

app.js

@@ -1,8 +1,8 @@
 import {FINAL160_SCOPE,FINAL160_INPUT_STATUS,applyFinal160Scope,filterFinal160Catalog,final160CoverageForFamily} from './final-scope.js?v=20261013-min128-v1';
 import {WEIGHT_TENTHS,parseWeights,addRankingMetrics} from './ranking.js?v=20261011-support-matched-v1';
 import {DEFAULT_PROFILE,profileLabel,defaultColumnVisible,metricAvailability,summarizeAvailability,visibleColumns,profileScopeText,aggregateTimedSubset,strictTimingMode} from './availability.js?v=20261013-overall-availability-v3';
-const CPP_LATEST_VIEW_SHA256='6a083b73b72dd7b93a2cb84bedf852c2df3ee025d0be104c2a1552cdd184dc80';
-const CPP_LATEST_VIEW_GZIP_SHA256='5069bbcb955fa3ea9b12eb1b8771500eb712d01ed529f9fbec0103b2f906fa9b';
+const CPP_LATEST_VIEW_SHA256='9d0729013696f867d0a007e122eb5d6c55e473da029ab5e5935b6b2bb80c818d';
+const CPP_LATEST_VIEW_GZIP_SHA256='78945c2427f6a4f11ebcd9d3b2836b143b6c9b342f4272f05fd0bde1e48b28c7';
 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;
@@ -384,7 +384,7 @@ function decodeCompactRecord(row,index) {
   return {_compact_index:index,dataset:t.datasets[row[0]],scope:t.scopes[row[1]],runtime:t.runtimes[row[2]],comparison_profile:t.comparison_profiles[row[3]],family:t.families[row[4]],method:t.configurations[row[5]],algorithm_variant:t.configurations[row[5]],compression_rate:row[6],compression_time_ns_per_point:row[7],decompression_time_ns_per_point:row[8],original_size_bytes:row[9],compressed_size_bytes:row[10],timing_column_count:row[11],timing_aggregation:t.timing_aggregations[row[12]],eligible_column_set_sha256:t.support_sets[row[13]],measurement_status:t.measurement_statuses[row[14]],timing_profile_status:t.timing_statuses[row[15]],binary_sha256:t.binary_hashes[row[16]]};
 }
 function applyCppLatestView() {
-  if(!cppLatestView||cppLatestView.schema!=='compressionbenchmark-cpp-latest-view-v1'||cppLatestView.status!=='built_from_published_main26_plus_completed_dsc2_reuse')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_dsc2_reuse_plus_completed_integer89_native15')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.');
@@ -465,7 +465,7 @@ void loadDatasetCatalog();
 async function sha256Hex(buffer){const digest=await crypto.subtle.digest('SHA-256',buffer);return [...new Uint8Array(digest)].map(byte=>byte.toString(16).padStart(2,'0')).join('');}
 async function gunzipBuffer(buffer,label){if(typeof DecompressionStream!=='function')throw new Error(`${label} requires browser gzip decompression support.`);try{return await new Response(new Blob([buffer]).stream().pipeThrough(new DecompressionStream('gzip'))).arrayBuffer();}catch(error){throw new Error(`${label} could not be decompressed: ${error instanceof Error?error.message:String(error)}`);}}
 try {
-  const [snapshotResponse,sidecarResponse]=await Promise.all([fetch('./ui-data.json?v=20261015-main26-dsc2-reuse-v3',{cache:'no-cache'}),fetch('./cpp-latest-view-main26.json.gz?v=20261015-main26-dsc2-reuse-v3',{cache:'no-cache'})]);
+  const [snapshotResponse,sidecarResponse]=await Promise.all([fetch('./ui-data.json?v=20261015-lossless-completion-1688-v1',{cache:'no-cache'}),fetch('./cpp-latest-view-main26.json.gz?v=20261015-lossless-completion-1688-v1',{cache:'no-cache'})]);
   if(!snapshotResponse.ok)throw new Error(`Snapshot request returned ${snapshotResponse.status}`);if(!sidecarResponse.ok)throw new Error(`Combined C++ sidecar request returned ${sidecarResponse.status}`);
   const [snapshotBuffer,sidecarGzipBuffer]=await Promise.all([snapshotResponse.arrayBuffer(),sidecarResponse.arrayBuffer()]);
   const sidecarGzipSha=await sha256Hex(sidecarGzipBuffer);if(sidecarGzipSha!==CPP_LATEST_VIEW_GZIP_SHA256)throw new Error('The compressed C++ sidecar transport does not match the frozen release.');

build_lossless_completion_site.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Append completed integer89 and native15 overlays to the published DSC2 site snapshot."""
+from __future__ import annotations
+import argparse,copy,datetime as dt,gzip,hashlib,importlib.util,json,math,shutil,statistics,subprocess,sys
+from collections import Counter,defaultdict
+from pathlib import Path
+
+PARENT_HEAD="3e03c82b1f7873db19ccbc0bf0f093fd02375a9f"
+PROFILE="cpp-native192-main26-whole-column-20261015-v1"
+AUTHORITY="cpp135_lossless_completion_server192_latest"
+VERSION="20261015-lossless-completion-1688-v1"
+OLD_STATUS="built_from_published_main26_plus_completed_dsc2_reuse"
+NEW_STATUS="built_from_published_dsc2_reuse_plus_completed_integer89_native15"
+TIMING_STATUS="timing_admitted_server192_main26_w1_r3_t1_column_mean_builtin_bitexact"
+ACCEPT="LOSSLESS_COMPLETION_1688_ACCEPTANCE.json"
+INTEGRATION="LOSSLESS_COMPLETION_1688_INTEGRATION.json"
+DATA_GZ="data-main26.json.gz";SIDE_GZ="cpp-latest-view-main26.json.gz"
+EVIDENCE={
+ 'integer89':{'DATASET_METHOD_RESULTS.jsonl.gz':'integer89-dataset-method-overlay.jsonl.gz','OVERLAY_RECEIPT.json':'INTEGER89_OVERLAY_RECEIPT.json','SOURCE_BINDINGS.json':'INTEGER89_SOURCE_BINDINGS.json'},
+ 'native15':{'DATASET_METHOD_RESULTS.jsonl.gz':'native15-dataset-method-overlay.jsonl.gz','OVERLAY_RECEIPT.json':'NATIVE15_OVERLAY_RECEIPT.json','SOURCE_BINDINGS.json':'NATIVE15_SOURCE_BINDINGS.json'},
+}
+def req(x,m):
+ if not x:raise RuntimeError(m)
+def sha(p):
+ h=hashlib.sha256()
+ with Path(p).open('rb') as f:
+  for b in iter(lambda:f.read(8<<20),b''):h.update(b)
+ return h.hexdigest()
+def canonical(v):return json.dumps(v,ensure_ascii=False,sort_keys=True,separators=(',',':'),allow_nan=False).encode()
+def csha(v):return hashlib.sha256(canonical(v)).hexdigest()
+def rj(p):
+ v=json.loads(Path(p).read_text());req(isinstance(v,dict),f'expected object {p}');return v
+def rgj(p):
+ with gzip.open(p,'rt') as f:v=json.load(f)
+ req(isinstance(v,dict),f'expected gzip object {p}');return v
+def rgl(p):
+ with gzip.open(p,'rt') as f:return [json.loads(l) for l in f if l.strip()]
+def wj(p,v):Path(p).write_text(json.dumps(v,ensure_ascii=False,indent=2,sort_keys=True,allow_nan=False)+'\n')
+def dgzip(src,dst):
+ with Path(src).open('rb') as s,Path(dst).open('wb') as raw:
+  with gzip.GzipFile(filename='',mode='wb',fileobj=raw,compresslevel=9,mtime=0) as z:shutil.copyfileobj(s,z,length=8<<20)
+def gz_content_sha(p):
+ h=hashlib.sha256()
+ with gzip.open(p,'rb') as f:
+  for b in iter(lambda:f.read(8<<20),b''):h.update(b)
+ return h.hexdigest()
+def finite(v):req(type(v) in (int,float) and math.isfinite(float(v)),f'nonfinite {v}');return float(v)
+def one(row,field):
+ v=row[field];vs=[v] if isinstance(v,str) else list(v);req(len(vs)==1 and isinstance(vs[0],str) and vs[0],f'expected one {field}');return vs[0]
+def strings(row,field):
+ v=row.get(field) or [];vs=[v] if isinstance(v,str) else list(v);req(all(isinstance(x,str) and x for x in vs),f'invalid {field}');return sorted(set(vs))
+def dscope(dtype):
+ d=dtype.lower()
+ if d.startswith(('int','uint')):return 'integer'
+ if d.startswith('float'):return 'float'
+ raise RuntimeError(dtype)
+def support_sha(cols):return csha(sorted(str(r['input_manifest_sha256']) for r in cols))
+def typed_route(cols):
+ groups={}
+ for r in cols:
+  config=one(r,'configurations');profile=one(r,'profile_versions');dtype=str(r['dtype']);k=(dtype,config,profile,str(r['runtime_binary_sha256']),str(r['selected_terminal_sha256']),str(r['selected_source']))
+  e=groups.setdefault(k,{'dtype':dtype,'dtype_scope':dscope(dtype),'configuration':config,'profile_version':profile,'runtime_binary_sha256':str(r['runtime_binary_sha256']),'selected_terminal_sha256':str(r['selected_terminal_sha256']),'source_selection':str(r['selected_source']),'execution_host':'192.168.99.20','producer_cli_sha256':set(),'timing_scopes':set(),'precision_semantics':set(),'implementations':set(),'column_count':0,'precision_charge_rows':0})
+  e['producer_cli_sha256'].update(strings(r,'producer_cli_sha256'));e['timing_scopes'].update(strings(r,'timing_scopes'));e['precision_semantics'].update(strings(r,'precision_semantics'));e['implementations'].update(strings(r,'implementations'));e['column_count']+=1;e['precision_charge_rows']+=int(r.get('precision_charge_rows',0))
+ routes=[]
+ for e in groups.values():routes.append({**e,'producer_cli_sha256':sorted(e['producer_cli_sha256']),'timing_scopes':sorted(e['timing_scopes']),'precision_semantics':sorted(e['precision_semantics']),'implementations':sorted(e['implementations'])})
+ routes.sort(key=lambda r:(r['dtype_scope'],r['dtype'],r['configuration'],r['profile_version'],r['runtime_binary_sha256'],r['selected_terminal_sha256']))
+ return {'routes':routes,'configurations':sorted({r['configuration'] for r in routes}),'profile_versions':sorted({r['profile_version'] for r in routes}),'producer_cli_sha256':sorted({x for r in routes for x in r['producer_cli_sha256']}),'runtime_binary_sha256_set':sorted({r['runtime_binary_sha256'] for r in routes}),'selected_terminal_sha256_set':sorted({r['selected_terminal_sha256'] for r in routes}),'source_selection_set':sorted({r['source_selection'] for r in routes})}
+def summarize(source,cols,scope):
+ s=cols if scope=='overall' else [r for r in cols if dscope(str(r['dtype']))==scope];req(s,f'absent scope {source["dataset_id"]}/{source["method"]}/{scope}');supported=sum(int(r['supported_valid_value_count']) for r in s);unsupported=sum(int(r['unsupported_valid_value_count']) for r in s);req(supported>0 and unsupported==0,'scope not fully numeric');numeric=[r for r in s if r['support_state']=='full_numeric'];original=sum(int(r['supported_original_numeric_bytes']) for r in s);compressed=sum(int(r['measured_complete_frame_bytes']) for r in s);route=typed_route(s)
+ out={'dataset_id':source['dataset_id'],'method':source['method'],'family':source['family'],'method_family':source['method_family'],'scope':scope,'support_state':'full_numeric','full_valid_support':True,'column_count':len(s),'full_numeric_columns':len(numeric),'partial_support_columns':0,'unsupported_columns':0,'not_applicable_columns':sum(r['support_state']=='not_applicable' for r in s),'supported_valid_value_count':supported,'unsupported_valid_value_count':0,'supported_original_numeric_bytes':original,'unsupported_original_numeric_bytes':0,'measured_complete_frame_bytes':compressed,'all_missing_complete_frame_bytes':sum(int(r['all_missing_complete_frame_bytes']) for r in s),'compression_ratio_column_arithmetic_mean':statistics.fmean(finite(r['compression_ratio']) for r in numeric),'secondary_pooled_compression_ratio':compressed/original,'compression_ns_per_valid_native_point_column_arithmetic_mean':statistics.fmean(finite(r['compression_ns_per_valid_native_point']) for r in numeric),'decompression_ns_per_valid_native_point_column_arithmetic_mean':statistics.fmean(finite(r['decompression_ns_per_valid_native_point']) for r in numeric),'profile_versions':route['profile_versions'],'configurations':route['configurations'],'producer_cli_sha256':route['producer_cli_sha256'],'runtime_binary_sha256_set':route['runtime_binary_sha256_set'],'selected_terminal_sha256_set':route['selected_terminal_sha256_set'],'source_selection_set':route['source_selection_set'],'support_sha256':support_sha(s),'typed_route_contract_sha256':csha(sorted(r['typed_route_contract_sha256'] for r in s)),'typed_route':route,'byte_boundary':'sum complete frame bytes over selected dtype-scope columns / original valid numeric bytes','timing_contract':'arithmetic mean of per-column ns/valid-native-point; W1/R3/T1; built-in exact Block equality outside timed interval'}
+ if scope=='overall':
+  req(out['support_sha256']==source['dataset_input_cohort_sha256'],'cohort changed');req(out['typed_route_contract_sha256']==source['typed_route_contract_sha256'],'route changed')
+  for f in ('column_count','supported_valid_value_count','supported_original_numeric_bytes','measured_complete_frame_bytes','all_missing_complete_frame_bytes'):req(out[f]==source[f],f'overall mismatch {f}')
+ return out
+def route_label(route,field):
+ vals=route[field]
+ if len(vals)==1:return vals[0]
+ comp='configuration' if field=='configurations' else 'profile_version'
+ return 'typed-route['+';'.join(f"{r['dtype']}={r[comp]}" for r in route['routes'])+']'
+def site_row(src,accept_sha):
+ route=src['typed_route'];bins=route['runtime_binary_sha256_set'];terms=route['selected_terminal_sha256_set'];sources=route['source_selection_set'];rsha=src['typed_route_contract_sha256'];binary=bins[0] if len(bins)==1 else None;runtime=f'cpp-native192-lossless-{binary[:8]}' if binary else f'cpp-native192-lossless-composite-{rsha[:8]}';config=route_label(route,'configurations');profiles=route_label(route,'profile_versions');orig=int(src['supported_original_numeric_bytes']);comp=int(src['measured_complete_frame_bytes']);points=int(src['supported_valid_value_count']);ct=finite(src['compression_ns_per_valid_native_point_column_arithmetic_mean']);dt=finite(src['decompression_ns_per_valid_native_point_column_arithmetic_mean'])
+ return {'schema':'compressionbenchmark-cpp135-lossless-completion-site-row-v1','dataset':src['dataset_id'],'scope':src['scope'],'runtime':runtime,'comparison_profile':PROFILE,'method':config,'family':src['method'],'algorithm_variant':f"{config} [{' + '.join(x[:8] for x in bins)}]",'is_best_rate_in_family':True,'original_size_bytes':orig,'compressed_size_bytes':comp,'point_count':points,'compression_rate':comp/orig,'compression_time_ns':ct*points,'decompression_time_ns':dt*points,'compression_time_ns_per_point':ct,'decompression_time_ns_per_point':dt,'timing_column_count':int(src['full_numeric_columns']),'timing_aggregation':'column_mean','eligible_dtype_scope':src['scope'],'eligible_column_set_sha256':src['support_sha256'],'eligible_column_set_status':'algorithm_independent_frozen_manifest_scope_cohort_sha256','measurement_status':'lossless_completion_integer89_native15_complete_builtin_bitexact_roundtrip','timing_profile_status':TIMING_STATUS,'execution_host':'192.168.99.20','binary_sha256':binary,'binary_sha256_set':bins,'producer_cli_sha256':route['producer_cli_sha256'][0] if len(route['producer_cli_sha256'])==1 else None,'producer_cli_sha256_set':route['producer_cli_sha256'],'profile_version':profiles,'typed_route':route['routes'],'typed_route_configurations':route['configurations'],'source_profile_composition':route['profile_versions'],'typed_route_contract_sha256':rsha,'input_version':'final135-frozen-inputs-20261014-v1','acceptance_sha256':accept_sha,'source_selection':sources[0] if len(sources)==1 else None,'source_selection_set':sources,'selected_terminal_sha256':terms[0] if len(terms)==1 else None,'selected_terminal_sha256_set':terms,'method_family':src['method_family'],'byte_boundary':src['byte_boundary'],'timing_contract':src['timing_contract'],'timing_stage_schedule':'W1; encode repeat 1,2,3; decode repeat 1,2,3; T1','column_arithmetic_mean_compression_rate':finite(src['compression_ratio_column_arithmetic_mean']),'all_missing_complete_frame_bytes':int(src['all_missing_complete_frame_bytes'])}
+def decoded(ui):
+ t=ui['record_tables'];out=[]
+ for r in ui['compact_records']:out.append({'dataset':t['datasets'][r[0]],'scope':t['scopes'][r[1]],'runtime':t['runtimes'][r[2]],'comparison_profile':t['comparison_profiles'][r[3]],'family':t['families'][r[4]],'measurement_status':t['measurement_statuses'][r[14]],'timing_profile_status':t['timing_statuses'][r[15]]})
+ return out
+def main():
+ ap=argparse.ArgumentParser();ap.add_argument('--baseline',type=Path,required=True);ap.add_argument('--integer89',type=Path,required=True);ap.add_argument('--native15',type=Path,required=True);ap.add_argument('--output',type=Path,required=True);a=ap.parse_args();base,i89,n15,out=map(Path,(a.baseline,a.integer89,a.native15,a.output));req(not out.exists(),'output exists')
+ rec89=rj(i89/'OVERLAY_RECEIPT.json');rec15=rj(n15/'OVERLAY_RECEIPT.json');req(rec89['status']=='complete_verified_not_published' and rec89['dataset_method_count']==89,'integer89 overlay incomplete');req(rec15['status']=='complete_verified_not_published' and rec15['dataset_method_count']==1599,'native15 overlay incomplete');shutil.copytree(base,out)
+ public={}
+ for label,root in [('integer89',i89),('native15',n15)]:
+  for src,dst in EVIDENCE[label].items():shutil.copy2(root/src,out/dst);public[dst]={'bytes':(out/dst).stat().st_size,'sha256':sha(out/dst)}
+ overlays=[]
+ for label,root,retained_name in [('integer89',i89,'RETAINED_INTEGER_COLUMNS.jsonl.gz'),('native15',n15,'RETAINED_COLUMNS.jsonl.gz')]:
+  ds=rgl(root/'DATASET_METHOD_RESULTS.jsonl.gz');cols=rgl(root/'COLUMN_RESULTS.jsonl.gz')+rgl(root/retained_name);by=defaultdict(list)
+  for r in cols:by[(str(r['dataset_id']),str(r['method']))].append(r)
+  sm={(str(r['dataset_id']),str(r['method'])):r for r in ds};req(set(by)==set(sm),f'{label} pair union')
+  for pair in sorted(sm):
+   scopes={'overall':summarize(sm[pair],by[pair],'overall')}
+   for s in ('float','integer'):
+    if any(dscope(str(r['dtype']))==s for r in by[pair]):scopes[s]=summarize(sm[pair],by[pair],s)
+   overlays.append((label,pair,scopes,sm[pair]))
+ req(len(overlays)==1688 and len({x[1] for x in overlays})==1688,'overlay pair count')
+ accept={'schema':'compressionbenchmark-cpp135-lossless-completion-1688-acceptance-v1','status':'accepted_completed_builtin_bitexact','created_at':dt.datetime.now(dt.timezone.utc).isoformat(),'parent_revision':PARENT_HEAD,'scope':{'integer89_pair_count':89,'native15_pair_count':1599,'pair_count':1688,'method_count':22,'dataset_count':135},'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 required exact complete original Block equality after warmup and every measured decode','overlay_receipts':{'integer89':sha(i89/'OVERLAY_RECEIPT.json'),'native15':sha(n15/'OVERLAY_RECEIPT.json')},'public_evidence':public};wj(out/ACCEPT,accept);asha=sha(out/ACCEPT)
+ additions=[];summaries={}
+ for label,pair,scopes,source in overlays:
+  summaries[pair]=scopes
+  for _,s in sorted(scopes.items()):additions.append(site_row(s,asha))
+ additions.sort(key=lambda r:(r['dataset'],r['family'],r['scope']))
+ data=rgj(base/DATA_GZ);old_n=len(data['dataset_results']);old_sha=csha(data['dataset_results']);data['dataset_results'].extend(additions);req(csha(data['dataset_results'][:old_n])==old_sha,'historical rows changed')
+ spec=importlib.util.spec_from_file_location('recompute',out/'build_accepted_completion_v7.py');helper=importlib.util.module_from_spec(spec);req(spec.loader is not None,'helper loader');spec.loader.exec_module(helper);helper.recompute(data);helper.update_methods(data,additions);data['benchmark']['implementation_runtimes']=sorted({r['comparison_profile'] for r in data['dataset_results']});data['benchmark']['exact_source_profiles']=sorted({r['runtime'] for r in data['dataset_results']});data['benchmark'].setdefault('runtime_hosts',{})[PROFILE]='192.168.99.20';run={'schema':'cpp135-lossless-completion-1688-site-import-v1','comparison_profile':PROFILE,'execution_host':'192.168.99.20','pair_count':1688,'numeric_row_count':len(additions),'timing_policy':accept['timing'],'acceptance':{'file':ACCEPT,'sha256':asha},'old_results_retained':True};data['source'].setdefault('measurement_runs',[]).append(run);cov=data['coverage'];cov.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({r['family'] for r in data['dataset_results']}),method_configuration_count=len({r['algorithm_variant'] for r in data['dataset_results']}),runtime_configuration_count=len({(r['comparison_profile'],r['algorithm_variant']) for r in data['dataset_results']}),runtime_count=len(data['benchmark']['implementation_runtimes']),runtimes=data['benchmark']['implementation_runtimes'],timing_unavailable_dataset_result_count=sum(r.get('timing_aggregation')=='unavailable' for r in data['dataset_results']));cov['cpp135_lossless_completion_1688']=run;wj(out/'data.json',data);dgzip(out/'data.json',out/DATA_GZ);subprocess.run([sys.executable,str(out/'build_ui_payload.py')],check=True,capture_output=True,text=True);newui=rj(out/'ui-data.json');old_ui=rj(base/'ui-data.json');req(newui['source_data_sha256']==sha(out/'data.json') and len(newui['compact_records'])==len(data['dataset_results']),'UI closure')
+ oldside=rgj(base/SIDE_GZ);od,nd=decoded(old_ui),decoded(newui);old_count=len(od);targets=set(summaries);selected=[]
+ for item in oldside['cpp']['selected_rows']:
+  d=od[item['raw_compact_index']]
+  if (d['dataset'],item['canonical_family']) not in targets:selected.append(copy.deepcopy(item))
+ byscope={(r['dataset'],r['family'],r['scope']):i for i,r in enumerate(additions,old_count)};req(len(byscope)==len(additions),'addition identities')
+ for k,idx in sorted(byscope.items()):
+  d=nd[idx];req((d['dataset'],d['family'],d['scope'])==k,'compact append mismatch');selected.append({'raw_compact_index':idx,'canonical_family':k[1],'source_family':k[1],'source_comparison_profile':PROFILE,'source_runtime':d['runtime'],'source_host':'192.168.99.20','authority':AUTHORITY,'pair_status':'numeric','timing_admitted':True,'measurement_status':d['measurement_status'],'timing_profile_status':d['timing_profile_status']})
+ prior={(r['dataset'],r['canonical_family']):r for r in oldside['cpp']['pair_ledger']};req(targets<=set(prior),'target ledger absent');ledger=[copy.deepcopy(r) for k,r in prior.items() if k not in targets];allsc=set(newui['record_tables']['scopes'])
+ for pair in sorted(targets):
+  scopes=sorted(summaries[pair]);indices=[byscope[(pair[0],pair[1],s)] for s in scopes];ov=summaries[pair]['overall'];bins=ov['runtime_binary_sha256_set'];terms=ov['selected_terminal_sha256_set'];sources=ov['source_selection_set'];ledger.append({'dataset':pair[0],'canonical_family':pair[1],'decision':'select_latest_completed_lossless_dtype_scopes','status':'numeric','source_comparison_profile':PROFILE,'source_hosts':['192.168.99.20'],'selected_raw_indices':indices,'selected_scopes':scopes,'missing_scopes_tombstoned':sorted(allsc-set(scopes)),'recency_rank':80,'authority':AUTHORITY,'reason':'Completed integer89/native15 typed route recovers all formerly unsupported numeric columns with built-in exact Block validation; unaffected successful columns retain their selected Main26 route.','acceptance_sha256':asha,'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':ov['typed_route_contract_sha256'],'scope_support_states':{s:'numeric' for s in scopes}})
+ selected.sort(key=lambda r:r['raw_compact_index']);ledger.sort(key=lambda r:(r['dataset'],r['canonical_family']));req(len({r['raw_compact_index'] for r in selected})==len(selected),'duplicate selected');active=set(oldside['cpp']['active_native85_families']);activeled=[r for r in ledger if r['canonical_family'] in active];req(len(activeled)==164*85,'ledger size');counts=Counter(r['status'] for r in activeled);scope_ds={};scope_pairs={}
+ for s in sorted(allsc):
+  ps=[]
+  for item in selected:
+   d=nd[item['raw_compact_index']]
+   if d['scope']==s:ps.append((d['dataset'],item['canonical_family']))
+  scope_ds[s]=len({p[0] for p in ps});scope_pairs[s]=len(set(ps))
+ timing=[r['raw_compact_index'] for r in selected if r['timing_admitted']];side=copy.deepcopy(oldside);side['status']=NEW_STATUS;side['baseline']={'revision':PARENT_HEAD,'ui_data_path':'ui-data.json','ui_data_sha256':sha(out/'ui-data.json'),'data_path':'data.json','data_sha256':sha(out/'data.json'),'compact_record_count':len(nd),'parent_published_payload':{'data_uncompressed_sha256':oldside['baseline']['data_sha256'],'ui_data_sha256':oldside['baseline']['ui_data_sha256'],'cpp_latest_view_uncompressed_sha256':hashlib.sha256(canonical(oldside)).hexdigest()}};side['identity_contract']['atomicity']='One newest authority wins per dataset and canonical C++ family; exactly 1,688 completed integer89/native15 pair decisions replace their prior rows.';side['precedence'].append({'rank':80,'authority':AUTHORITY,'scope':'1,688 completed lossless numeric pair recoveries on the frozen 135-dataset scope'});side['receipts'][ACCEPT]={'path':ACCEPT,'sha256':asha,'schema':accept['schema'],'status':accept['status']};side['cpp']['selected_rows']=selected;side['cpp']['pair_ledger']=ledger;c=side['cpp']['counts'];c.update({'active_native85_pair_conclusions':len(activeled),'active_native85_pair_status':dict(sorted(counts.items())),'active_native85_numeric_pairs':counts['numeric'],'active_native85_partial_numeric_pairs':counts['partial_numeric'],'active_native85_measured_numeric_pairs':counts['numeric']+counts['partial_numeric'],'active_native85_terminal_tombstone_pairs':counts['not_applicable']+counts['unsupported'],'selected_compact_row_count':len(selected),'timing_admitted_selected_row_count':len(timing),'scope_numeric_dataset_counts':scope_ds,'scope_numeric_pair_counts':scope_pairs,'lossless_completion_pair_count':1688,'lossless_completion_numeric_scope_row_count':len(additions)});side['cpp']['timing_subset']={'contract':'Row-local admitted timing; completed integer89/native15 measurements use the same server-192 W1/R3/T1 column-mean contract with exact Block checks.','selected_raw_indices':timing,'selected_row_count':len(timing),'source_profile_counts':dict(sorted(Counter(nd[r['raw_compact_index']]['comparison_profile'] for r in selected if r['timing_admitted']).items()))};side['warnings'].append('The 1,688 recovery decisions retain all typed route, binary, terminal, source, configuration and profile sets; composite rows do not invent a scalar binary.');wj(out/'cpp-latest-view.json',side);side_sha=sha(out/'cpp-latest-view.json');dgzip(out/'cpp-latest-view.json',out/SIDE_GZ);sgz=sha(out/SIDE_GZ)
+ appp=out/'app.js';app=appp.read_text();old_content=gz_content_sha(base/SIDE_GZ);req(app.count(old_content)==1 and app.count(sha(base/SIDE_GZ))==1,'app SHA anchors');app=app.replace(old_content,side_sha).replace(sha(base/SIDE_GZ),sgz);oldtoken='20261015-main26-dsc2-reuse-v3';req(app.count(oldtoken)==2,'app token');app=app.replace(oldtoken,VERSION);req(app.count(OLD_STATUS)==1,'status guard');appp.write_text(app.replace(OLD_STATUS,NEW_STATUS));subprocess.run(['node','--check',str(appp)],check=True);idx=out/'index.html';txt=idx.read_text();req(txt.count(oldtoken)==1,'index token');idx.write_text(txt.replace(oldtoken,VERSION));req(sha(out/'ranking.js')==sha(base/'ranking.js'),'ranking changed')
+ readme=out/'README.md';readme.write_text(readme.read_text()+f'\n## Completed lossless recovery\n\nThis release appends {len(additions)} dtype-scope rows and replaces exactly 1,688 latest C++ pair decisions from the completed integer89 and native15 campaigns. All measurements ran on server 192 with W1/R3/T1 and built-in exact complete-Block checks. Historical rows and the prior DSC2 release remain unchanged.\n')
+ manifest=rj(out/'manifest.json');data_sha=sha(out/'data.json');data_gz_sha=sha(out/DATA_GZ);ui_sha=sha(out/'ui-data.json');manifest['data_file']=DATA_GZ;manifest['data_sha256']=data_gz_sha;manifest['data_uncompressed_sha256']=data_sha;manifest['counts']=cov;manifest['measurement_runs']=data['source']['measurement_runs'];manifest['cpp135_lossless_completion_1688']={**run,'public_evidence':public,'acceptance':{'file':ACCEPT,'sha256':asha},'builder':{'file':Path(__file__).name,'sha256':sha(Path(__file__))}};manifest['data_transport']={'file':DATA_GZ,'sha256':data_gz_sha,'uncompressed_sha256':data_sha,'encoding':'gzip'};manifest['cpp_latest_view']={'file':SIDE_GZ,'sha256':sgz,'uncompressed_sha256':side_sha,'encoding':'gzip','schema':side['schema'],'status':side['status']};manifest['latest_page_inputs']={'compact_data':{'file':'ui-data.json','sha256':ui_sha},'selection_sidecar':copy.deepcopy(manifest['cpp_latest_view'])};wj(out/'manifest.json',manifest);shutil.copy2(Path(__file__),out/Path(__file__).name)
+ changed=[DATA_GZ,'ui-data.json',SIDE_GZ,'app.js','index.html','README.md','manifest.json',*public.keys(),ACCEPT,Path(__file__).name];integ={'schema':'compressionbenchmark-cpp135-lossless-completion-1688-integration-v1','status':'passed_not_published','created_at':dt.datetime.now(dt.timezone.utc).isoformat(),'parent_revision':PARENT_HEAD,'historical_dataset_result_count':old_n,'historical_dataset_results_canonical_sha256':old_sha,'new_dataset_result_count':len(additions),'final_dataset_result_count':len(data['dataset_results']),'scope':{'pair_count':1688,'integer89':89,'native15':1599,'numeric_scope_rows':len(additions)},'files':{n:{'bytes':(out/n).stat().st_size,'sha256':sha(out/n)} for n in changed},'publication_file_list':changed+[INTEGRATION],'semantic_checks':{'only_exact_1688_latest_cpp_pair_decisions_replaced':True,'historical_rows_retained':True,'same_host_w1_r3_t1':True,'built_in_exact_block_bound':True,'typed_routes_and_binary_sets_explicit':True,'ranking_unchanged':True,'data_ui_sidecar_hash_closure':True},'transport':{'data_gzip_sha256':data_gz_sha,'data_uncompressed_sha256':data_sha,'sidecar_gzip_sha256':sgz,'sidecar_uncompressed_sha256':side_sha}};wj(out/INTEGRATION,integ);print(json.dumps({'status':integ['status'],'output':str(out),'pair_count':1688,'numeric_rows_added':len(additions),'active_status_counts':dict(counts),'data_sha256':data_sha,'sidecar_sha256':side_sha,'manifest_sha256':sha(out/'manifest.json'),'integration_sha256':sha(out/INTEGRATION),'publication_files':integ['publication_file_list']},indent=2,sort_keys=True))
+if __name__=='__main__':main()

cpp-latest-view-main26.json.gz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5069bbcb955fa3ea9b12eb1b8771500eb712d01ed529f9fbec0103b2f906fa9b
-size 851074
+oid sha256:78945c2427f6a4f11ebcd9d3b2836b143b6c9b342f4272f05fd0bde1e48b28c7
+size 1678540

data-main26.json.gz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1325c3fc08c93cedd8f8714662690fb09586c7460e4110a88a0148544df639b8
-size 10056008
+oid sha256:59ed00b27881b407aed705212f51841836295dced5aea0dcd0ca9f028455daa8
+size 14942911

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-main26-dsc2-reuse-v3" type="module"></script>
+  <script src="app.js?v=20261015-lossless-completion-1688-v1" type="module"></script>
 </head>
 <body>
   <a class="skip-link" href="#content">Skip to results</a>

integer89-dataset-method-overlay.jsonl.gz

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

manifest.json

@@ -33,7 +33,7 @@
   },
   "counts": {
     "catalog_dataset_count": 164,
-    "configuration_aggregate_row_count": 5914,
+    "configuration_aggregate_row_count": 6308,
     "corrected_five425": {
       "active_method_count": 85,
       "all_na_pair_count": 0,
@@ -66,6 +66,26 @@
       "special_support_review_pair_count": 8,
       "timing_admitted": false
     },
+    "cpp135_lossless_completion_1688": {
+      "acceptance": {
+        "file": "LOSSLESS_COMPLETION_1688_ACCEPTANCE.json",
+        "sha256": "30f6ada7bfde981151b9a7c2ee66644146ba602cca135411eb72d8bb48bca982"
+      },
+      "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+      "execution_host": "192.168.99.20",
+      "numeric_row_count": 3915,
+      "old_results_retained": true,
+      "pair_count": 1688,
+      "schema": "cpp135-lossless-completion-1688-site-import-v1",
+      "timing_policy": {
+        "aggregation": "equal-column mean of median(aligned block sums)/valid native points",
+        "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+        "cross_host_mixing": false,
+        "host": "192.168.99.20",
+        "schedule": "one warmup; three encode measurements; then three decode measurements",
+        "threads": 1
+      }
+    },
     "cpp135_main26": {
       "aggregate_receipt": {
         "file": "CPP135_MAIN26_AGGREGATE_RECEIPT.json",
@@ -139,7 +159,7 @@
       }
     },
     "dataset_count": 164,
-    "dataset_result_row_count": 99068,
+    "dataset_result_row_count": 102983,
     "excluded_datasets": [
       "Arade",
       "app_flow",
@@ -151,7 +171,7 @@
       "tiktok_trending_hashtags_music",
       "youtube_trending_2019_2020"
     ],
-    "family_best_aggregate_row_count": 1997,
+    "family_best_aggregate_row_count": 2008,
     "float_scaling9": {
       "acceptance": {
         "file": "FLOAT_SCALING9_SITE_ACCEPTANCE.json",
@@ -175,7 +195,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": 988,
+    "method_configuration_count": 1324,
     "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,
@@ -474,7 +494,7 @@
     "native86_unresolved_problem_pair_count": 0,
     "native86_v9_recovered_pair_count": 154,
     "paper_leaderboard_row_count": 0,
-    "runtime_configuration_count": 1636,
+    "runtime_configuration_count": 1972,
     "runtime_count": 14,
     "runtimes": [
       "cpp",
@@ -499,6 +519,56 @@
     "timing_dataset_aggregate_result_count": 0,
     "timing_unavailable_dataset_result_count": 67677
   },
+  "cpp135_lossless_completion_1688": {
+    "acceptance": {
+      "file": "LOSSLESS_COMPLETION_1688_ACCEPTANCE.json",
+      "sha256": "30f6ada7bfde981151b9a7c2ee66644146ba602cca135411eb72d8bb48bca982"
+    },
+    "builder": {
+      "file": "build_lossless_completion_site.py",
+      "sha256": "1ab499a9408a9ad40cd1bf3773e9f078b6e4b5abf34d9ada2af295b906f9f13b"
+    },
+    "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+    "execution_host": "192.168.99.20",
+    "numeric_row_count": 3915,
+    "old_results_retained": true,
+    "pair_count": 1688,
+    "public_evidence": {
+      "INTEGER89_OVERLAY_RECEIPT.json": {
+        "bytes": 1229,
+        "sha256": "9c73de8af669b141f87acceebb11c9aba1a707a5af80cf55064f010fbddad338"
+      },
+      "INTEGER89_SOURCE_BINDINGS.json": {
+        "bytes": 5913,
+        "sha256": "9c045d5ae0bc5ad948f343c1d438245858fe568705c1c1bd3569a75524e4dddd"
+      },
+      "NATIVE15_OVERLAY_RECEIPT.json": {
+        "bytes": 1119,
+        "sha256": "6dc3eeeb2d435a7bab52ae803bca3241971ac0727159ae6b88c9693c7bf2ef1e"
+      },
+      "NATIVE15_SOURCE_BINDINGS.json": {
+        "bytes": 644095,
+        "sha256": "3904277d13d9ad3abf0abacd273967b5137f193214834b17bcbb080cb0d831eb"
+      },
+      "integer89-dataset-method-overlay.jsonl.gz": {
+        "bytes": 17646,
+        "sha256": "a302881e785f537a7394261cd404bc3a72c9a575e82afadeb5b823346f5c08c7"
+      },
+      "native15-dataset-method-overlay.jsonl.gz": {
+        "bytes": 846187,
+        "sha256": "827c61cadd7ade050b1992c28ebaa3bc5be27faaa0fb92c2b0c38ed1b6d2b33e"
+      }
+    },
+    "schema": "cpp135-lossless-completion-1688-site-import-v1",
+    "timing_policy": {
+      "aggregation": "equal-column mean of median(aligned block sums)/valid native points",
+      "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+      "cross_host_mixing": false,
+      "host": "192.168.99.20",
+      "schedule": "one warmup; three encode measurements; then three decode measurements",
+      "threads": 1
+    }
+  },
   "cpp135_main26": {
     "aggregate_receipt": {
       "file": "CPP135_MAIN26_AGGREGATE_RECEIPT.json",
@@ -633,19 +703,19 @@
     "encoding": "gzip",
     "file": "cpp-latest-view-main26.json.gz",
     "schema": "compressionbenchmark-cpp-latest-view-v1",
-    "sha256": "5069bbcb955fa3ea9b12eb1b8771500eb712d01ed529f9fbec0103b2f906fa9b",
-    "status": "built_from_published_main26_plus_completed_dsc2_reuse",
-    "uncompressed_sha256": "6a083b73b72dd7b93a2cb84bedf852c2df3ee025d0be104c2a1552cdd184dc80"
+    "sha256": "78945c2427f6a4f11ebcd9d3b2836b143b6c9b342f4272f05fd0bde1e48b28c7",
+    "status": "built_from_published_dsc2_reuse_plus_completed_integer89_native15",
+    "uncompressed_sha256": "9d0729013696f867d0a007e122eb5d6c55e473da029ab5e5935b6b2bb80c818d"
   },
   "data_file": "data-main26.json.gz",
-  "data_sha256": "1325c3fc08c93cedd8f8714662690fb09586c7460e4110a88a0148544df639b8",
+  "data_sha256": "59ed00b27881b407aed705212f51841836295dced5aea0dcd0ca9f028455daa8",
   "data_transport": {
     "encoding": "gzip",
     "file": "data-main26.json.gz",
-    "sha256": "1325c3fc08c93cedd8f8714662690fb09586c7460e4110a88a0148544df639b8",
-    "uncompressed_sha256": "39b017fab9ee25ca7758f678d30212ed21d4e8c138de2161daa0b33b530dd376"
+    "sha256": "59ed00b27881b407aed705212f51841836295dced5aea0dcd0ca9f028455daa8",
+    "uncompressed_sha256": "71340b992134dacb4dd1dea100218a86585521c3ea03da75098be49af47cc721"
   },
-  "data_uncompressed_sha256": "39b017fab9ee25ca7758f678d30212ed21d4e8c138de2161daa0b33b530dd376",
+  "data_uncompressed_sha256": "71340b992134dacb4dd1dea100218a86585521c3ea03da75098be49af47cc721",
   "dataset_catalog_sha256": "47869c8078e8c864810d4f961fa5879e120943bb3f371b39f0adc74f3de2ee2d",
   "excluded_content": [
     "raw datasets",
@@ -690,15 +760,15 @@
   "latest_page_inputs": {
     "compact_data": {
       "file": "ui-data.json",
-      "sha256": "8a1f02ce7e55e68f464a7daec6dab8a8c1a12fd632d5b351bb0d4474522570ae"
+      "sha256": "f47285cda7d42c6fe4846ebb717669eabe4f80953902f7609e51c912d0d34c30"
     },
     "selection_sidecar": {
       "encoding": "gzip",
       "file": "cpp-latest-view-main26.json.gz",
       "schema": "compressionbenchmark-cpp-latest-view-v1",
-      "sha256": "5069bbcb955fa3ea9b12eb1b8771500eb712d01ed529f9fbec0103b2f906fa9b",
-      "status": "built_from_published_main26_plus_completed_dsc2_reuse",
-      "uncompressed_sha256": "6a083b73b72dd7b93a2cb84bedf852c2df3ee025d0be104c2a1552cdd184dc80"
+      "sha256": "78945c2427f6a4f11ebcd9d3b2836b143b6c9b342f4272f05fd0bde1e48b28c7",
+      "status": "built_from_published_dsc2_reuse_plus_completed_integer89_native15",
+      "uncompressed_sha256": "9d0729013696f867d0a007e122eb5d6c55e473da029ab5e5935b6b2bb80c818d"
     }
   },
   "measurement_runs": [
@@ -1384,6 +1454,26 @@
         "schedule": "one warmup; three encode measurements; then three decode measurements",
         "threads": 1
       }
+    },
+    {
+      "acceptance": {
+        "file": "LOSSLESS_COMPLETION_1688_ACCEPTANCE.json",
+        "sha256": "30f6ada7bfde981151b9a7c2ee66644146ba602cca135411eb72d8bb48bca982"
+      },
+      "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+      "execution_host": "192.168.99.20",
+      "numeric_row_count": 3915,
+      "old_results_retained": true,
+      "pair_count": 1688,
+      "schema": "cpp135-lossless-completion-1688-site-import-v1",
+      "timing_policy": {
+        "aggregation": "equal-column mean of median(aligned block sums)/valid native points",
+        "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+        "cross_host_mixing": false,
+        "host": "192.168.99.20",
+        "schedule": "one warmup; three encode measurements; then three decode measurements",
+        "threads": 1
+      }
     }
   ],
   "native86_imports": {

native15-dataset-method-overlay.jsonl.gz

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