Add 24 lossless BOS/REGER DSC2 results for current 135 datasets

Reuse 24 completed BOS/REGER dataset-method measurements with bit-exact DSC2 float scaling. Preserve historical rows and the latest main26 integer columns; retain full adapter and binary provenance. Update only the affected C++ results; BOS and REGER now have numeric results for all 135 datasets. Frozen 17-file release; server166 current v4 synchronized.

DSC2_REUSE_INDEPENDENT_VERIFICATION.json

@@ -0,0 +1,21 @@
+{
+  "checks": {
+    "all_24_dataset_methods_complete": true,
+    "bos_reger_input_cohort_equal_per_dataset": true,
+    "composite_dataset_metrics_reproduced": true,
+    "dsc2_float_dataset_summary_reproduced": true,
+    "dsc2_summary_exactly_transcribed": true,
+    "exact_counts": true,
+    "retained_integer_rows_byte_semantics_unchanged": true,
+    "typed_words_excluded_from_point_denominator": true
+  },
+  "counts": {
+    "dataset_methods": 24,
+    "datasets": 12,
+    "replacement_column_methods": 616,
+    "retained_integer_column_methods": 176
+  },
+  "overlay_receipt_sha256": "ff1d11bb0d66ae33c7961c0534981ac6c0240974b6a29a30f9d752c700475f0e",
+  "schema": "cpp135-dsc2-overlay-independent-verification-v1",
+  "status": "passed"
+}

DSC2_REUSE_OVERLAY_RECEIPT.json

@@ -0,0 +1,52 @@
+{
+  "aggregation": {
+    "compression_ratio_primary": "arithmetic mean of full-numeric column complete-frame/original-byte ratios",
+    "compression_ratio_secondary": "sum complete frame bytes / sum original native numeric bytes",
+    "timing_primary": "arithmetic mean of per-column median(aligned 3 sums)/valid native point count",
+    "timing_runs": "one warmup and three measured repeats per block, one thread"
+  },
+  "bitexact_proof": "CLI warmup and every measured decode compare complete original Block bit-exactly",
+  "created_epoch_ns": 1792062372231890000,
+  "dataset_count": 12,
+  "dataset_method_count": 24,
+  "dsc2_replacement_column_method_count": 616,
+  "files": {
+    "COLUMN_RESULTS.jsonl.gz": {
+      "bytes": 142163,
+      "sha256": "3be84e62791a7b6218e58d3d717f2ffd5b3c38e835a8b9f81cec7615237a7e8e"
+    },
+    "CONSISTENCY_REPORT.json": {
+      "bytes": 658,
+      "sha256": "a63767caf2081bcca9c952832e7dc008e7d9c711151854a5fe09eedd01e49ee0"
+    },
+    "DATASET_METHOD_RESULTS.jsonl.gz": {
+      "bytes": 6754,
+      "sha256": "b63ad6ac3e481202d53ea09b17a7c4f3bc340b5dc086b08f8e25cc798603d9db"
+    },
+    "DSC2_COLUMN_AUDIT.jsonl.gz": {
+      "bytes": 56678,
+      "sha256": "68f41f2addb0fb9c2dea0f6741e5c3d3fce568db3454d1d227faad7fb97fb029"
+    },
+    "RETAINED_INTEGER_COLUMNS.jsonl.gz": {
+      "bytes": 37767,
+      "sha256": "dc539e507ffd03b24d807cc0e69d3b3d86931231ffd6eecdb07686c95f5adbdd"
+    },
+    "SOURCE_BINDINGS.json": {
+      "bytes": 2676,
+      "sha256": "d73e349d3c500dda077012cb1a33375643df62c379fa9e4f611d5c4d8327f005"
+    }
+  },
+  "method_count": 2,
+  "metric_denominator": "original native numeric points from the unchanged main26 manifests; DSC2 integer_words is a typed backend word count and is excluded from compression and timing point denominators",
+  "original_partial_float_column_count": 178,
+  "publication_state": "not published; does not mutate COMPLETE_CURRENT or any baseline/writer",
+  "recovered_formerly_unsupported_block_method_count": 15780,
+  "retained_integer_column_method_count": 176,
+  "schema": "cpp135-dsc2-overlay-receipt-v1",
+  "source_bindings_sha256": "d73e349d3c500dda077012cb1a33375643df62c379fa9e4f611d5c4d8327f005",
+  "status": "complete_local_overlay_not_published_not_current",
+  "support_state_counts": {
+    "full_numeric": 24
+  },
+  "total_composite_column_method_count": 792
+}

DSC2_REUSE_SITE_ACCEPTANCE.json

@@ -0,0 +1,62 @@
+{
+  "composite_route": "successful main26 integer columns retained; DSC2 v2 float columns replace old partial float columns; all binaries, terminals, profiles and sources remain explicit sets",
+  "created_at": "2026-10-15T13:52:04.195000+00:00",
+  "independent_compact_verification_sha256": "3c4c8a705cb26f53e922378508b38c92909396fadc84582a2ff22582d38857c9",
+  "lossless": "producer warmup and each measured decode compare the complete original Block bit-exactly",
+  "metric_denominator": "original valid native points; typed DSC2 integer_words is evidence only",
+  "overlay_receipt_sha256": "ff1d11bb0d66ae33c7961c0534981ac6c0240974b6a29a30f9d752c700475f0e",
+  "parent_revision": "c7aeab66168050289ce9332afb62f2e339a1c7bb",
+  "public_evidence": {
+    "DSC2_REUSE_INDEPENDENT_VERIFICATION.json": {
+      "bytes": 739,
+      "sha256": "3c4c8a705cb26f53e922378508b38c92909396fadc84582a2ff22582d38857c9"
+    },
+    "DSC2_REUSE_OVERLAY_RECEIPT.json": {
+      "bytes": 2358,
+      "sha256": "ff1d11bb0d66ae33c7961c0534981ac6c0240974b6a29a30f9d752c700475f0e"
+    },
+    "DSC2_REUSE_SOURCE_BINDINGS.json": {
+      "bytes": 2676,
+      "sha256": "d73e349d3c500dda077012cb1a33375643df62c379fa9e4f611d5c4d8327f005"
+    },
+    "dsc2-reuse-column-audit.jsonl.gz": {
+      "bytes": 56678,
+      "sha256": "68f41f2addb0fb9c2dea0f6741e5c3d3fce568db3454d1d227faad7fb97fb029"
+    },
+    "dsc2-reuse-column-overlay.jsonl.gz": {
+      "bytes": 142163,
+      "sha256": "3be84e62791a7b6218e58d3d717f2ffd5b3c38e835a8b9f81cec7615237a7e8e"
+    },
+    "dsc2-reuse-dataset-method-overlay.jsonl.gz": {
+      "bytes": 6754,
+      "sha256": "b63ad6ac3e481202d53ea09b17a7c4f3bc340b5dc086b08f8e25cc798603d9db"
+    },
+    "dsc2-reuse-retained-integer-columns.jsonl.gz": {
+      "bytes": 37767,
+      "sha256": "dc539e507ffd03b24d807cc0e69d3b3d86931231ffd6eecdb07686c95f5adbdd"
+    }
+  },
+  "schema": "compressionbenchmark-cpp135-dsc2-reuse-site-acceptance-v1",
+  "scope": {
+    "dataset_count": 12,
+    "float_column_method_count": 616,
+    "method_count": 2,
+    "methods": [
+      "BOS",
+      "REGER"
+    ],
+    "numeric_scope_row_count": 60,
+    "pair_count": 24,
+    "retained_integer_column_method_count": 176
+  },
+  "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",
+    "precision": "charged once per float method-column",
+    "schedule": "one warmup; three encode measurements; then three decode measurements",
+    "threads": 1
+  }
+}

DSC2_REUSE_SITE_INTEGRATION.json

@@ -0,0 +1,122 @@
+{
+  "created_at": "2026-10-15T13:52:14.243249+00:00",
+  "files": {
+    "DSC2_REUSE_INDEPENDENT_VERIFICATION.json": {
+      "bytes": 739,
+      "sha256": "3c4c8a705cb26f53e922378508b38c92909396fadc84582a2ff22582d38857c9"
+    },
+    "DSC2_REUSE_OVERLAY_RECEIPT.json": {
+      "bytes": 2358,
+      "sha256": "ff1d11bb0d66ae33c7961c0534981ac6c0240974b6a29a30f9d752c700475f0e"
+    },
+    "DSC2_REUSE_SITE_ACCEPTANCE.json": {
+      "bytes": 2649,
+      "sha256": "64968f6dd5b8402a7fc5e6416d02b4c462dea496ce0cd4e6dac391218632331f"
+    },
+    "DSC2_REUSE_SOURCE_BINDINGS.json": {
+      "bytes": 2676,
+      "sha256": "d73e349d3c500dda077012cb1a33375643df62c379fa9e4f611d5c4d8327f005"
+    },
+    "README.md": {
+      "bytes": 4756,
+      "sha256": "d2a22110babcae4e416c07984c93546ab29b862676f253e481afc0ac2acc6b60"
+    },
+    "app.js": {
+      "bytes": 69469,
+      "sha256": "79f86219dab7eb2eddc3672d6886839e4db6f0ba5afde9925e525f577c2fbd11"
+    },
+    "build_dsc2_reuse_site.py": {
+      "bytes": 38589,
+      "sha256": "9d5a3a8e2db84f94bde4236f4c7ba4855f53b31db703c3178fda1f25f7a2bf78"
+    },
+    "cpp-latest-view-main26.json.gz": {
+      "bytes": 851074,
+      "sha256": "5069bbcb955fa3ea9b12eb1b8771500eb712d01ed529f9fbec0103b2f906fa9b"
+    },
+    "data-main26.json.gz": {
+      "bytes": 10056008,
+      "sha256": "1325c3fc08c93cedd8f8714662690fb09586c7460e4110a88a0148544df639b8"
+    },
+    "dsc2-reuse-column-audit.jsonl.gz": {
+      "bytes": 56678,
+      "sha256": "68f41f2addb0fb9c2dea0f6741e5c3d3fce568db3454d1d227faad7fb97fb029"
+    },
+    "dsc2-reuse-column-overlay.jsonl.gz": {
+      "bytes": 142163,
+      "sha256": "3be84e62791a7b6218e58d3d717f2ffd5b3c38e835a8b9f81cec7615237a7e8e"
+    },
+    "dsc2-reuse-dataset-method-overlay.jsonl.gz": {
+      "bytes": 6754,
+      "sha256": "b63ad6ac3e481202d53ea09b17a7c4f3bc340b5dc086b08f8e25cc798603d9db"
+    },
+    "dsc2-reuse-retained-integer-columns.jsonl.gz": {
+      "bytes": 37767,
+      "sha256": "dc539e507ffd03b24d807cc0e69d3b3d86931231ffd6eecdb07686c95f5adbdd"
+    },
+    "index.html": {
+      "bytes": 17820,
+      "sha256": "7af57432ae7fb892ece2e7e9b452204795e4fd5431e292a26e96ff9cb64c50a4"
+    },
+    "manifest.json": {
+      "bytes": 99777,
+      "sha256": "93ddbee464262b049bc0676d88eaa691e579d093616a29cb7028506b34f8faff"
+    },
+    "ui-data.json": {
+      "bytes": 9711250,
+      "sha256": "8a1f02ce7e55e68f464a7daec6dab8a8c1a12fd632d5b351bb0d4474522570ae"
+    }
+  },
+  "final_dataset_result_count": 99068,
+  "historical_dataset_result_count": 99008,
+  "historical_dataset_results_canonical_sha256": "cbd272987fc3d8b08a3e0fc3541a70165ff303704d989e596a1b0be9cebbc822",
+  "new_dataset_result_count": 60,
+  "parent_revision": "c7aeab66168050289ce9332afb62f2e339a1c7bb",
+  "publication_file_list": [
+    "data-main26.json.gz",
+    "ui-data.json",
+    "cpp-latest-view-main26.json.gz",
+    "app.js",
+    "index.html",
+    "README.md",
+    "manifest.json",
+    "dsc2-reuse-column-overlay.jsonl.gz",
+    "dsc2-reuse-dataset-method-overlay.jsonl.gz",
+    "dsc2-reuse-retained-integer-columns.jsonl.gz",
+    "dsc2-reuse-column-audit.jsonl.gz",
+    "DSC2_REUSE_OVERLAY_RECEIPT.json",
+    "DSC2_REUSE_SOURCE_BINDINGS.json",
+    "DSC2_REUSE_INDEPENDENT_VERIFICATION.json",
+    "DSC2_REUSE_SITE_ACCEPTANCE.json",
+    "build_dsc2_reuse_site.py",
+    "DSC2_REUSE_SITE_INTEGRATION.json"
+  ],
+  "schema": "compressionbenchmark-cpp135-dsc2-reuse-site-integration-v3",
+  "scope": {
+    "dataset_count": 12,
+    "method_count": 2,
+    "numeric_scope_rows": 60,
+    "pair_count": 24
+  },
+  "semantic_checks": {
+    "all_historical_dataset_rows_retained_in_canonical_order": true,
+    "bitexact_decode_evidence_bound": true,
+    "composite_scalar_binary_is_null_and_binary_set_is_complete": true,
+    "data_ui_sidecar_hash_closure": true,
+    "dsc2_route_and_binary_provenance_remains_explicit": true,
+    "exact_60_new_numeric_scope_rows_appended": true,
+    "main26_3510_import_not_replayed": true,
+    "main26_and_dsc2_same_actual_timing_contract": true,
+    "only_exact_24_latest_cpp_pair_decisions_replaced": true,
+    "ranking_js_unchanged": true,
+    "same_host_no_cross_host_timing": true,
+    "successful_176_integer_column_routes_retained": true,
+    "w1_r3_t1_three_encode_then_three_decode": true
+  },
+  "status": "passed_not_published",
+  "transport": {
+    "data_gzip_sha256": "1325c3fc08c93cedd8f8714662690fb09586c7460e4110a88a0148544df639b8",
+    "data_uncompressed_sha256": "39b017fab9ee25ca7758f678d30212ed21d4e8c138de2161daa0b33b530dd376",
+    "sidecar_gzip_sha256": "5069bbcb955fa3ea9b12eb1b8771500eb712d01ed529f9fbec0103b2f906fa9b",
+    "sidecar_uncompressed_sha256": "6a083b73b72dd7b93a2cb84bedf852c2df3ee025d0be104c2a1552cdd184dc80"
+  }
+}

DSC2_REUSE_SOURCE_BINDINGS.json

@@ -0,0 +1,35 @@
+{
+  "base_aggregate": {
+    "column_results_sha256": "6c3d693556fb58f8277ac201dfe217ea85aec65489a707260af85981faa21e9b",
+    "dataset_method_results_sha256": "5ba82d79f07327d6a5b2e1405d3f58db7e72930dcd0284132764ff48a8b5859b",
+    "directory": "/Users/xiaojinzhao/Documents/GitHub/web_compression/analysis_outputs/cpp135_delivery_20261015_v1/aggregate",
+    "receipt_sha256": "f098925d8bd0b5718b102a8b6921b1234ced3baec80e2faeb47f2edb71c2d337"
+  },
+  "composite_route_rule": "retain every successful main26 integer column with its original source/profile/binary/terminal; replace every planned float column with the matching DSC2 v2 result",
+  "dsc2": {
+    "bitexact_proof": "CLI warmup and every measured decode compare complete original Block bit-exactly",
+    "directory": "/Users/xiaojinzhao/Documents/GitHub/web_compression/analysis_outputs/cpp135_remaining_fill_20261015_v1/dsc2_delivery/compact",
+    "float_columns_sha256": "75e4b50f431cc2df33ad2357d10c6f08ba9623fd90e4b577fdf97d32513f3138",
+    "plan_sha256": "3a71365a2050ab2181326fa81043da5a5ccecdc67b2b0aea2daf742277e03f9c",
+    "profile": "baseline86-decimal-scaling-int64-exact-v2",
+    "repair_completed_sha256": "943390f6f548855e1977e9d529fc70ea62c54d034f0cfae56f84acda4b45fcff",
+    "runtime_binary_sha256": "dc082279e11b1459d68f796a6bc00aa44f95c81e5e42b9787f7667f094e48549",
+    "terminal_sha256_by_dataset": {
+      "Bar-Crawl": "bb836be3ed64cb5f0080686d9898e5ddc8463d9931874ffbc03f364121a28bb6",
+      "current_velocity": "8f8cfa4a2a1c8a8b801b6d0ea271df582c39781fcb18d7bc49e9d950c321e83f",
+      "eea_pm25_forecasting": "7e6ef268bf0f9b5059a8a666381157b2ee63051bf551f5f600ddd1435aec227e",
+      "goes_omni_electron_flux_forecasting": "a4c163884cbe6353fbbcd1093984776acd0f226012b07d63df9ba0ce379d722b",
+      "kdd_cup_2018": "3ccdfdf690c479dd0298c5b328290ca5dc410eecc3919ef1cb4b7a27424c2d6b",
+      "kraken-trading-data": "aa2d64b661386edfa879e671b379d519d46a10232b68374fef1c8e1eaaf62d25",
+      "ooni_censorship_historical": "f84f07101d124bad6ca42da8cc6cdce2bafc19245703ab5827f05b37be9df4f6",
+      "orbital_chaos_nasa_ssc": "a53946de5b1a07ae99a4f87887762dcb745c8eb5ac5c308229002aa80346a783",
+      "reg_forecasting_v2": "c3e1b6f508c43fb09f3485766b97f853376e2e0877ce14003fdf4bbf31d89e47",
+      "stock_dataset": "003a439b51a688db76f877f944cc836059228640a32b08b0139f916ace22e977",
+      "timeseries_1mn_stocks": "d6e3af52efa19f25e10d0fac369ef4b5113e8e873e19c81b1728eeca1b29b682",
+      "wind_farms_minutely": "cb4c07b99b19715c2f3853f52744cb918c6b0b0635373141a82d932c02f1f6f4"
+    }
+  },
+  "host": "192",
+  "schema": "cpp135-dsc2-overlay-source-bindings-v1",
+  "status": "frozen_local_overlay_not_published"
+}

README.md

@@ -22,3 +22,7 @@ Compression rate remains complete compressed-frame bytes divided by original num
 Historical operator byte effects are retained as diagnostics. Current-scope, corrected-input operator results remain pending and must be independently accepted before replacing them. Dataset corrections are documented in `FINAL160_FORMAT_AUDIT.json`; its previous 160-dataset investigation is a historical parent-scope audit, not the active selection list.
 
 The historical `164×85=13,940` terminal matrix remains downloadable and is not a current-scope completion claim. [Parent documentation](https://huggingface.co/spaces/THULab/CompressionBenchmark/blob/799b74b93d0c1a25b7b7a085614f6a2c8e631468/README.md) preserves the previous pipeline and provenance.
+
+## 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.

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='f1aef2f23a0374e43ddde18d5ab2b29095ff344cf9ef4d591cd8037e55958a6e';
-const CPP_LATEST_VIEW_GZIP_SHA256='818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180';
+const CPP_LATEST_VIEW_SHA256='6a083b73b72dd7b93a2cb84bedf852c2df3ee025d0be104c2a1552cdd184dc80';
+const CPP_LATEST_VIEW_GZIP_SHA256='5069bbcb955fa3ea9b12eb1b8771500eb712d01ed529f9fbec0103b2f906fa9b';
 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_verified_live_float9_baseline_and_completed_main26')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_main26_plus_completed_dsc2_reuse')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-gzip-v4',{cache:'no-cache'}),fetch('./cpp-latest-view-main26.json.gz?v=20261015-main26-gzip-v4',{cache:'no-cache'})]);
+  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'})]);
   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_dsc2_reuse_site.py

@@ -0,0 +1,691 @@
+#!/usr/bin/env python3
+"""Build the unpublished 24-pair BOS/REGER DSC2 website increment.
+
+The canonical parent is candidate_main26_v4 with the three published v5
+source-reference files applied. Historical result rows are immutable and the
+builder appends only the numeric scope rows for the 24 repaired pairs. Latest
+C++ selection changes only for those exact pairs.
+"""
+
+from __future__ import annotations
+
+import argparse
+import copy
+import datetime as dt
+import gzip
+import hashlib
+import importlib.util
+import json
+import math
+import shutil
+import statistics
+import subprocess
+import sys
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any
+
+
+PARENT_HEAD = "c7aeab66168050289ce9332afb62f2e339a1c7bb"
+PROFILE = "cpp-native192-main26-whole-column-20261015-v1"
+AUTHORITY = "cpp135_main26_dsc2_reuse_server192_latest"
+VERSION = "20261015-main26-dsc2-reuse-v3"
+BASELINE_CPP_LATEST_STATUS = "built_from_verified_live_float9_baseline_and_completed_main26"
+DSC2_CPP_LATEST_STATUS = "built_from_published_main26_plus_completed_dsc2_reuse"
+MAIN26_TIMING_PROFILE_STATUS = "timing_admitted_server192_main26_w1_r3_t1_column_mean_builtin_bitexact"
+MAIN26_TIMING_CONTRACT = (
+    "arithmetic mean of per-column ns/valid-native-point; W1/R3/T1; "
+    "built-in exact Block equality outside timed interval"
+)
+ACCEPTANCE = "DSC2_REUSE_SITE_ACCEPTANCE.json"
+INTEGRATION = "DSC2_REUSE_SITE_INTEGRATION.json"
+DATA_GZ = "data-main26.json.gz"
+SIDECAR_GZ = "cpp-latest-view-main26.json.gz"
+EVIDENCE = {
+    "COLUMN_RESULTS.jsonl.gz": "dsc2-reuse-column-overlay.jsonl.gz",
+    "DATASET_METHOD_RESULTS.jsonl.gz": "dsc2-reuse-dataset-method-overlay.jsonl.gz",
+    "RETAINED_INTEGER_COLUMNS.jsonl.gz": "dsc2-reuse-retained-integer-columns.jsonl.gz",
+    "DSC2_COLUMN_AUDIT.jsonl.gz": "dsc2-reuse-column-audit.jsonl.gz",
+    "OVERLAY_RECEIPT.json": "DSC2_REUSE_OVERLAY_RECEIPT.json",
+    "SOURCE_BINDINGS.json": "DSC2_REUSE_SOURCE_BINDINGS.json",
+    "INDEPENDENT_VERIFICATION.json": "DSC2_REUSE_INDEPENDENT_VERIFICATION.json",
+}
+
+
+def require(value: Any, message: str) -> None:
+    if not value:
+        raise RuntimeError(message)
+
+
+def sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        for block in iter(lambda: f.read(8 << 20), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def canonical(value: Any) -> bytes:
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"), allow_nan=False).encode()
+
+
+def canonical_sha(value: Any) -> str:
+    return hashlib.sha256(canonical(value)).hexdigest()
+
+
+def read_json(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text())
+    require(isinstance(value, dict), f"expected JSON object: {path}")
+    return value
+
+
+def read_gzip_json(path: Path) -> dict[str, Any]:
+    with gzip.open(path, "rt") as f:
+        value = json.load(f)
+    require(isinstance(value, dict), f"expected gzip JSON object: {path}")
+    return value
+
+
+def read_gzip_jsonl(path: Path) -> list[dict[str, Any]]:
+    with gzip.open(path, "rt") as f:
+        return [json.loads(line) for line in f if line.strip()]
+
+
+def write_json(path: Path, value: Any) -> None:
+    path.write_text(json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n")
+
+
+def deterministic_gzip(source: Path, target: Path) -> None:
+    with source.open("rb") as src, target.open("wb") as raw:
+        with gzip.GzipFile(filename="", mode="wb", fileobj=raw, compresslevel=9, mtime=0) as zipped:
+            shutil.copyfileobj(src, zipped, length=8 << 20)
+
+
+def gzip_content_sha256(path: Path) -> str:
+    h = hashlib.sha256()
+    with gzip.open(path, "rb") as f:
+        for block in iter(lambda: f.read(8 << 20), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def finite(value: Any) -> float:
+    require(type(value) in (int, float) and math.isfinite(float(value)), f"non-finite metric: {value!r}")
+    return float(value)
+
+
+def one(row: dict[str, Any], field: str) -> str:
+    value = row[field]
+    values = [value] if isinstance(value, str) else list(value)
+    require(len(values) == 1 and isinstance(values[0], str) and values[0], f"expected one {field}")
+    return values[0]
+
+
+def string_set(row: dict[str, Any], field: str) -> list[str]:
+    value = row.get(field) or []
+    values = [value] if isinstance(value, str) else list(value)
+    require(all(isinstance(item, str) and item for item in values), f"invalid {field}")
+    return sorted(set(values))
+
+
+def dtype_scope(dtype: str) -> str:
+    if dtype.lower().startswith(("int", "uint")):
+        return "integer"
+    if dtype.lower().startswith("float"):
+        return "float"
+    raise RuntimeError(f"unsupported numeric dtype: {dtype}")
+
+
+def support_sha(columns: list[dict[str, Any]]) -> str:
+    values = [str(row["input_manifest_sha256"]) for row in columns]
+    require(all(len(value) == 64 for value in values), "input manifest SHA missing")
+    return canonical_sha(sorted(values))
+
+
+def typed_route(columns: list[dict[str, Any]]) -> dict[str, Any]:
+    grouped: dict[tuple[str, ...], dict[str, Any]] = {}
+    for row in columns:
+        configuration = one(row, "configurations")
+        profile = one(row, "profile_versions")
+        dtype = str(row["dtype"])
+        key = (
+            dtype, configuration, profile, str(row["runtime_binary_sha256"]),
+            str(row["selected_terminal_sha256"]), str(row["selected_source"]),
+        )
+        entry = grouped.setdefault(key, {
+            "dtype": dtype,
+            "dtype_scope": dtype_scope(dtype),
+            "configuration": configuration,
+            "profile_version": profile,
+            "runtime_binary_sha256": str(row["runtime_binary_sha256"]),
+            "selected_terminal_sha256": str(row["selected_terminal_sha256"]),
+            "source_selection": str(row["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,
+        })
+        entry["producer_cli_sha256"].update(string_set(row, "producer_cli_sha256"))
+        entry["timing_scopes"].update(string_set(row, "timing_scopes"))
+        entry["precision_semantics"].update(string_set(row, "precision_semantics"))
+        entry["implementations"].update(string_set(row, "implementations"))
+        entry["column_count"] += 1
+        entry["precision_charge_rows"] += int(row.get("precision_charge_rows", 0))
+    routes = []
+    for entry in grouped.values():
+        routes.append({
+            **entry,
+            "producer_cli_sha256": sorted(entry["producer_cli_sha256"]),
+            "timing_scopes": sorted(entry["timing_scopes"]),
+            "precision_semantics": sorted(entry["precision_semantics"]),
+            "implementations": sorted(entry["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: dict[str, Any], columns: list[dict[str, Any]], scope: str) -> dict[str, Any]:
+    selected = columns if scope == "overall" else [r for r in columns if dtype_scope(str(r["dtype"])) == scope]
+    require(selected, f"absent scope {source['dataset_id']}/{source['method']}/{scope}")
+    supported = sum(int(r["supported_valid_value_count"]) for r in selected)
+    unsupported = sum(int(r["unsupported_valid_value_count"]) for r in selected)
+    require(supported > 0 and unsupported == 0, "DSC2 reusable scope is not fully numeric")
+    numeric = [r for r in selected if r["support_state"] == "full_numeric"]
+    original = sum(int(r["supported_original_numeric_bytes"]) for r in selected)
+    compressed = sum(int(r["measured_complete_frame_bytes"]) for r in selected)
+    route = typed_route(selected)
+    result = {
+        "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(selected), "full_numeric_columns": len(numeric),
+        "partial_support_columns": 0, "unsupported_columns": 0,
+        "not_applicable_columns": sum(r["support_state"] == "not_applicable" for r in selected),
+        "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 selected),
+        "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(selected),
+        "typed_route_contract_sha256": canonical_sha(sorted(r["typed_route_contract_sha256"] for r in selected)),
+        "typed_route": route,
+        "byte_boundary": "sum complete NGF1 frame bytes over selected dtype-scope columns / original valid numeric bytes",
+        # The original Main26 and DSC2 continuations use the same server-192
+        # W1/R3/T1, column-mean timing contract.  Route/version differences
+        # remain explicit in typed_route, profile_version, measurement_status,
+        # binary/source sets, and timing_stage_schedule; they are not timing
+        # contract boundaries.
+        "timing_contract": MAIN26_TIMING_CONTRACT,
+    }
+    if scope == "overall":
+        require(result["support_sha256"] == source["dataset_input_cohort_sha256"], "overall input cohort changed")
+        require(result["typed_route_contract_sha256"] == source["typed_route_contract_sha256"], "overall typed route changed")
+        for field in ("column_count", "supported_valid_value_count", "supported_original_numeric_bytes",
+                      "measured_complete_frame_bytes", "all_missing_complete_frame_bytes"):
+            require(result[field] == source[field], f"overlay overall field mismatch: {field}")
+    return result
+
+
+def route_label(route: dict[str, Any], field: str) -> str:
+    values = route[field]
+    if len(values) == 1:
+        return values[0]
+    component = "configuration" if field == "configurations" else "profile_version"
+    return "typed-route[" + ";".join(
+        f"{r['dtype']}={r[component]}" for r in route["routes"]
+    ) + "]"
+
+
+def make_site_row(source: dict[str, Any], acceptance_sha: str) -> dict[str, Any]:
+    route = source["typed_route"]
+    binaries = route["runtime_binary_sha256_set"]
+    terminals = route["selected_terminal_sha256_set"]
+    sources = route["source_selection_set"]
+    route_sha = source["typed_route_contract_sha256"]
+    binary = binaries[0] if len(binaries) == 1 else None
+    runtime = (
+        f"cpp-native192-main26-{binary[:8]}" if binary and binary.startswith("0558378c")
+        else f"cpp-native192-main26-dsc2-{binary[:8]}" if binary
+        else f"cpp-native192-main26-composite-{route_sha[:8]}"
+    )
+    configuration = route_label(route, "configurations")
+    profiles = route_label(route, "profile_versions")
+    original = int(source["supported_original_numeric_bytes"])
+    compressed = int(source["measured_complete_frame_bytes"])
+    points = int(source["supported_valid_value_count"])
+    cpp = finite(source["compression_ns_per_valid_native_point_column_arithmetic_mean"])
+    dpp = finite(source["decompression_ns_per_valid_native_point_column_arithmetic_mean"])
+    return {
+        "schema": "compressionbenchmark-cpp135-main26-dsc2-reuse-site-row-v1",
+        "dataset": source["dataset_id"], "scope": source["scope"],
+        "runtime": runtime, "comparison_profile": PROFILE,
+        "method": configuration, "family": source["method"],
+        "algorithm_variant": f"{configuration} [{' + '.join(x[:8] for x in binaries)}]",
+        "is_best_rate_in_family": True,
+        "original_size_bytes": original, "compressed_size_bytes": compressed,
+        "point_count": points, "compression_rate": compressed / original,
+        "compression_time_ns": cpp * points, "decompression_time_ns": dpp * points,
+        "compression_time_ns_per_point": cpp, "decompression_time_ns_per_point": dpp,
+        "timing_column_count": int(source["full_numeric_columns"]), "timing_aggregation": "column_mean",
+        "eligible_dtype_scope": source["scope"], "eligible_column_set_sha256": source["support_sha256"],
+        "eligible_column_set_status": "algorithm_independent_frozen_manifest_scope_cohort_sha256",
+        "measurement_status": "main26_dsc2_reuse_complete_valid_support_builtin_bitexact_roundtrip",
+        "timing_profile_status": MAIN26_TIMING_PROFILE_STATUS,
+        "execution_host": "192.168.99.20", "binary_sha256": binary,
+        "binary_sha256_set": binaries,
+        "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": route_sha,
+        "input_version": "final135-frozen-inputs-20261014-v1",
+        "acceptance_sha256": acceptance_sha,
+        "source_selection": sources[0] if len(sources) == 1 else None,
+        "source_selection_set": sources,
+        "selected_terminal_sha256": terminals[0] if len(terminals) == 1 else None,
+        "selected_terminal_sha256_set": terminals,
+        "method_family": source["method_family"], "byte_boundary": source["byte_boundary"],
+        "timing_contract": source["timing_contract"],
+        "timing_stage_schedule": "W1; encode repeat 1,2,3; decode repeat 1,2,3; T1",
+        "column_arithmetic_mean_compression_rate": finite(source["compression_ratio_column_arithmetic_mean"]),
+        "all_missing_complete_frame_bytes": int(source["all_missing_complete_frame_bytes"]),
+    }
+
+
+def compact_rows(ui: dict[str, Any]) -> list[dict[str, Any]]:
+    tables = ui["record_tables"]
+    return [{
+        "dataset": tables["datasets"][r[0]], "scope": tables["scopes"][r[1]],
+        "runtime": tables["runtimes"][r[2]], "comparison_profile": tables["comparison_profiles"][r[3]],
+        "family": tables["families"][r[4]], "measurement_status": tables["measurement_statuses"][r[14]],
+        "timing_profile_status": tables["timing_statuses"][r[15]],
+    } for r in ui["compact_records"]]
+
+
+def replace_sidecar(old: dict[str, Any], old_ui: dict[str, Any], new_ui: dict[str, Any],
+                    additions: list[dict[str, Any]], targets: set[tuple[str, str]],
+                    summaries: dict[tuple[str, str], dict[str, dict[str, Any]]],
+                    acceptance_sha: str, data_sha: str, ui_sha: str) -> dict[str, Any]:
+    old_decoded, new_decoded = compact_rows(old_ui), compact_rows(new_ui)
+    old_count = len(old_decoded)
+    retained = []
+    for item in old["cpp"]["selected_rows"]:
+        decoded = old_decoded[item["raw_compact_index"]]
+        if (decoded["dataset"], item["canonical_family"]) not in targets:
+            retained.append(copy.deepcopy(item))
+    addition_by_scope = {(r["dataset"], r["family"], r["scope"]): i for i, r in enumerate(additions, old_count)}
+    require(len(addition_by_scope) == len(additions), "duplicate DSC2 appended scope row")
+    for key, index in sorted(addition_by_scope.items()):
+        decoded = new_decoded[index]
+        require((decoded["dataset"], decoded["family"], decoded["scope"]) == key, "compact row mismatch")
+        retained.append({
+            "raw_compact_index": index, "canonical_family": key[1], "source_family": key[1],
+            "source_comparison_profile": PROFILE, "source_runtime": decoded["runtime"],
+            "source_host": "192.168.99.20", "authority": AUTHORITY,
+            "pair_status": "numeric", "timing_admitted": True,
+            "measurement_status": decoded["measurement_status"],
+            "timing_profile_status": decoded["timing_profile_status"],
+        })
+    old_target_ledger = [r for r in old["cpp"]["pair_ledger"] if (r["dataset"], r["canonical_family"]) in targets]
+    require(len(old_target_ledger) == 24 and all(r["status"] == "partial_numeric" for r in old_target_ledger),
+            "expected 24 prior partial main26 decisions")
+    ledger = [copy.deepcopy(r) for r in old["cpp"]["pair_ledger"]
+              if (r["dataset"], r["canonical_family"]) not in targets]
+    all_scopes = set(new_ui["record_tables"]["scopes"])
+    for pair in sorted(targets):
+        scopes = sorted(summaries[pair])
+        indices = [addition_by_scope[(pair[0], pair[1], scope)] for scope in scopes]
+        overall = summaries[pair]["overall"]
+        binaries = overall["runtime_binary_sha256_set"]
+        terminals = overall["selected_terminal_sha256_set"]
+        sources = overall["source_selection_set"]
+        ledger.append({
+            "dataset": pair[0], "canonical_family": pair[1],
+            "decision": "select_latest_main26_dsc2_reuse_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(all_scopes - set(scopes)),
+            "recency_rank": 70, "authority": AUTHORITY,
+            "reason": (
+                "Completed DSC2 v2 float route recovers all formerly unsupported blocks; successful main26 "
+                "integer columns are retained. Overall and dtype scopes use one same-host staged W1/R3/T1 contract."
+            ),
+            "acceptance_sha256": acceptance_sha,
+            "source_selection": sources[0] if len(sources) == 1 else None,
+            "source_selection_set": sources,
+            "runtime_binary_sha256": binaries[0] if len(binaries) == 1 else None,
+            "runtime_binary_sha256_set": binaries,
+            "selected_terminal_sha256": terminals[0] if len(terminals) == 1 else None,
+            "selected_terminal_sha256_set": terminals,
+            "typed_route_contract_sha256": overall["typed_route_contract_sha256"],
+            "scope_support_states": {scope: "numeric" for scope in scopes},
+        })
+    retained.sort(key=lambda r: r["raw_compact_index"])
+    ledger.sort(key=lambda r: (r["dataset"], r["canonical_family"]))
+    require(len({r["raw_compact_index"] for r in retained}) == len(retained), "duplicate selected row")
+    active = set(old["cpp"]["active_native85_families"])
+    active_ledger = [r for r in ledger if r["canonical_family"] in active]
+    require(len(active_ledger) == 164 * 85, "active85 ledger size changed")
+    status_counts = Counter(r["status"] for r in active_ledger)
+    scope_dataset_counts, scope_pair_counts = {}, {}
+    for scope in sorted(all_scopes):
+        pairs = []
+        for item in retained:
+            decoded = new_decoded[item["raw_compact_index"]]
+            if decoded["scope"] == scope:
+                pairs.append((decoded["dataset"], item["canonical_family"]))
+        scope_dataset_counts[scope] = len({p[0] for p in pairs})
+        scope_pair_counts[scope] = len(set(pairs))
+    timing = [r["raw_compact_index"] for r in retained if r["timing_admitted"]]
+    sidecar = copy.deepcopy(old)
+    sidecar["status"] = "built_from_published_main26_plus_completed_dsc2_reuse"
+    sidecar["baseline"] = {
+        "revision": PARENT_HEAD, "ui_data_path": "ui-data.json", "ui_data_sha256": ui_sha,
+        "data_path": "data.json", "data_sha256": data_sha, "compact_record_count": len(new_decoded),
+        "parent_published_payload": {
+            "data_uncompressed_sha256": old["baseline"]["data_sha256"],
+            "ui_data_sha256": old["baseline"]["ui_data_sha256"],
+            "cpp_latest_view_uncompressed_sha256": sha256_bytes(canonical(old)),
+        },
+    }
+    sidecar["identity_contract"]["atomicity"] = (
+        "One newest authority wins per dataset and canonical C++ family. DSC2 reuse atomically replaces only "
+        "the exact 24 BOS/REGER pairs; all other Main26 and legacy decisions are retained."
+    )
+    sidecar["precedence"].append({
+        "rank": 70, "authority": AUTHORITY,
+        "scope": "12 measured datasets x BOS/REGER; repaired float columns plus retained successful integer columns",
+    })
+    sidecar["receipts"][ACCEPTANCE] = {
+        "path": ACCEPTANCE, "sha256": acceptance_sha,
+        "schema": "compressionbenchmark-cpp135-dsc2-reuse-site-acceptance-v1",
+        "status": "accepted_completed_builtin_bitexact",
+    }
+    sidecar["cpp"]["selected_rows"] = retained
+    sidecar["cpp"]["pair_ledger"] = ledger
+    counts = sidecar["cpp"]["counts"]
+    old_main = dict(counts["main26_pair_status"])
+    require(old_main.get("partial_numeric") >= 24, "main26 partial count cannot absorb DSC2 recovery")
+    old_main["partial_numeric"] -= 24
+    old_main["numeric"] += 24
+    counts.update({
+        "active_native85_pair_conclusions": len(active_ledger),
+        "active_native85_pair_status": dict(sorted(status_counts.items())),
+        "active_native85_numeric_pairs": status_counts["numeric"],
+        "active_native85_partial_numeric_pairs": status_counts["partial_numeric"],
+        "active_native85_measured_numeric_pairs": status_counts["numeric"] + status_counts["partial_numeric"],
+        "active_native85_terminal_tombstone_pairs": status_counts["not_applicable"] + status_counts["unsupported"],
+        "selected_compact_row_count": len(retained), "timing_admitted_selected_row_count": len(timing),
+        "scope_numeric_dataset_counts": scope_dataset_counts, "scope_numeric_pair_counts": scope_pair_counts,
+        "main26_pair_status": dict(sorted(old_main.items())), "dsc2_reuse_pair_count": 24,
+        "dsc2_reuse_numeric_scope_row_count": len(additions),
+    })
+    sidecar["cpp"]["timing_subset"] = {
+        "contract": (
+            "Row-local admitted timing. The 24 DSC2 reuse pairs remain on server 192 and use the Main26 "
+            "W1/R3/T1 staged column contract: three encode repeats, then three decode repeats."
+        ),
+        "selected_raw_indices": timing, "selected_row_count": len(timing),
+        "source_profile_counts": dict(sorted(Counter(
+            new_decoded[r["raw_compact_index"]]["comparison_profile"] for r in retained if r["timing_admitted"]
+        ).items())),
+    }
+    sidecar["warnings"].append(
+        "DSC2 reuse changes only 24 BOS/REGER latest decisions. Composite rows preserve each integer/float "
+        "binary, terminal, source and typed route explicitly; no scalar binary is invented."
+    )
+    return sidecar
+
+
+def sha256_bytes(payload: bytes) -> str:
+    return hashlib.sha256(payload).hexdigest()
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--baseline-v4", type=Path, required=True)
+    ap.add_argument("--v5-patch", type=Path, required=True)
+    ap.add_argument("--overlay", type=Path, required=True)
+    ap.add_argument("--output", type=Path, required=True)
+    args = ap.parse_args()
+    baseline, patch, overlay, output = map(Path.resolve, (args.baseline_v4, args.v5_patch, args.overlay, args.output))
+    require(not output.exists(), "output already exists; preserve it and choose a new directory")
+    require(read_json(overlay / "OVERLAY_RECEIPT.json")["status"] == "complete_local_overlay_not_published_not_current", "overlay incomplete")
+    require(read_json(overlay / "INDEPENDENT_VERIFICATION.json")["status"] == "passed", "overlay verification failed")
+    actual = read_json(baseline.parents[1] / "publication" / "ACTUAL_PUBLICATION_V5.json")
+    require(actual["revision"] == PARENT_HEAD and actual["runtime"]["stage"] == "RUNNING", "published v5 parent differs")
+
+    shutil.copytree(baseline, output)
+    plan = read_json(patch / "release-plan.json")
+    for item in plan["files"]:
+        src, dst = patch / "files" / item["path"], output / item["path"]
+        require(sha256(src) == item["sha256"], f"v5 patch SHA differs: {item['path']}")
+        shutil.copy2(src, dst)
+    for source, public in EVIDENCE.items():
+        shutil.copy2(overlay / source, output / public)
+
+    dataset_rows = read_gzip_jsonl(overlay / "DATASET_METHOD_RESULTS.jsonl.gz")
+    float_rows = read_gzip_jsonl(overlay / "COLUMN_RESULTS.jsonl.gz")
+    integer_rows = read_gzip_jsonl(overlay / "RETAINED_INTEGER_COLUMNS.jsonl.gz")
+    require(len(dataset_rows) == 24 and len(float_rows) == 616 and len(integer_rows) == 176, "overlay counts differ")
+    by_pair = defaultdict(list)
+    for row in float_rows + integer_rows:
+        by_pair[str(row["dataset_id"]), str(row["method"])].append(row)
+    source_by_pair = {(str(r["dataset_id"]), str(r["method"])): r for r in dataset_rows}
+    require(set(by_pair) == set(source_by_pair) and len(source_by_pair) == 24, "overlay pair identities differ")
+    summaries = {}
+    for pair in sorted(source_by_pair):
+        columns = by_pair[pair]
+        scopes = {"overall": summarize(source_by_pair[pair], columns, "overall"),
+                  "float": summarize(source_by_pair[pair], columns, "float")}
+        if any(dtype_scope(str(r["dtype"])) == "integer" for r in columns):
+            scopes["integer"] = summarize(source_by_pair[pair], columns, "integer")
+        summaries[pair] = scopes
+    require(sum(len(v) for v in summaries.values()) == 60, "expected 60 repaired scope rows")
+
+    evidence_hashes = {public: {"bytes": (output / public).stat().st_size, "sha256": sha256(output / public)}
+                       for public in EVIDENCE.values()}
+    acceptance = {
+        "schema": "compressionbenchmark-cpp135-dsc2-reuse-site-acceptance-v1",
+        "status": "accepted_completed_builtin_bitexact", "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "parent_revision": PARENT_HEAD,
+        "scope": {"dataset_count": 12, "method_count": 2, "pair_count": 24,
+                  "numeric_scope_row_count": 60, "float_column_method_count": 616,
+                  "retained_integer_column_method_count": 176, "methods": ["BOS", "REGER"]},
+        "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",
+            "precision": "charged once per float method-column",
+            "cross_host_mixing": False,
+        },
+        "lossless": "producer warmup and each measured decode compare the complete original Block bit-exactly",
+        "metric_denominator": "original valid native points; typed DSC2 integer_words is evidence only",
+        "composite_route": "successful main26 integer columns retained; DSC2 v2 float columns replace old partial float columns; all binaries, terminals, profiles and sources remain explicit sets",
+        "overlay_receipt_sha256": sha256(overlay / "OVERLAY_RECEIPT.json"),
+        "independent_compact_verification_sha256": sha256(overlay / "INDEPENDENT_VERIFICATION.json"),
+        "public_evidence": evidence_hashes,
+    }
+    write_json(output / ACCEPTANCE, acceptance)
+    acceptance_sha = sha256(output / ACCEPTANCE)
+    additions = [make_site_row(summary, acceptance_sha) for pair in sorted(summaries)
+                 for _, summary in sorted(summaries[pair].items())]
+    additions.sort(key=lambda r: (r["dataset"], r["family"], r["scope"]))
+
+    data = read_gzip_json(baseline / DATA_GZ)
+    old_rows_sha = canonical_sha(data["dataset_results"])
+    old_count = len(data["dataset_results"])
+    require(old_count == 99008, "published Main26 canonical row count differs")
+    require(not any(r.get("measurement_status") == "main26_dsc2_reuse_complete_valid_support_builtin_bitexact_roundtrip"
+                    for r in data["dataset_results"]), "DSC2 reuse is already present")
+    data["dataset_results"].extend(additions)
+    require(canonical_sha(data["dataset_results"][:old_count]) == old_rows_sha, "historical rows changed")
+    helper_path = output / "build_accepted_completion_v7.py"
+    spec = importlib.util.spec_from_file_location("dsc2_recompute", helper_path)
+    helper = importlib.util.module_from_spec(spec)
+    require(spec.loader is not None, "cannot load aggregate recompute helper")
+    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_summary = {
+        "schema": "cpp135-main26-dsc2-reuse-site-import-v1", "comparison_profile": PROFILE,
+        "execution_host": "192.168.99.20", "pair_count": 24, "numeric_row_count": len(additions),
+        "dataset_count": 12, "methods": ["BOS", "REGER"],
+        "timing_policy": acceptance["timing"], "acceptance": {"file": ACCEPTANCE, "sha256": acceptance_sha},
+        "old_results_retained": True,
+    }
+    data["source"].setdefault("measurement_runs", []).append(run_summary)
+    coverage = data["coverage"]
+    coverage.update(
+        dataset_result_row_count=len(data["dataset_results"]),
+        configuration_aggregate_row_count=len(data["configuration_aggregates"]),
+        family_best_aggregate_row_count=len(data["family_best_aggregates"]),
+        method_family_count=len({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"]),
+    )
+    coverage["cpp135_main26_dsc2_reuse"] = run_summary
+    write_json(output / "data.json", data)
+    deterministic_gzip(output / "data.json", output / DATA_GZ)
+    subprocess.run([sys.executable, str(output / "build_ui_payload.py")], check=True, capture_output=True, text=True)
+    new_ui = read_json(output / "ui-data.json")
+    data_sha, ui_sha = sha256(output / "data.json"), sha256(output / "ui-data.json")
+    require(new_ui["source_data_sha256"] == data_sha and len(new_ui["compact_records"]) == len(data["dataset_results"]), "data/UI closure differs")
+    old_ui = read_json(baseline / "ui-data.json")
+    old_sidecar = read_gzip_json(baseline / SIDECAR_GZ)
+    sidecar = replace_sidecar(old_sidecar, old_ui, new_ui, additions, set(source_by_pair), summaries,
+                              acceptance_sha, data_sha, ui_sha)
+    write_json(output / "cpp-latest-view.json", sidecar)
+    sidecar_sha = sha256(output / "cpp-latest-view.json")
+    deterministic_gzip(output / "cpp-latest-view.json", output / SIDECAR_GZ)
+    sidecar_gz_sha = sha256(output / SIDECAR_GZ)
+
+    app_path = output / "app.js"
+    app = app_path.read_text()
+    old_sidecar_sha = gzip_content_sha256(baseline / SIDECAR_GZ)
+    require(app.count(old_sidecar_sha) == 1 and app.count(sha256(baseline / SIDECAR_GZ)) == 1, "app sidecar SHA anchors differ")
+    app = app.replace(old_sidecar_sha, sidecar_sha).replace(sha256(baseline / SIDECAR_GZ), sidecar_gz_sha)
+    require(app.count("20261015-main26-gzip-v4") == 2, "app cache token count differs")
+    app = app.replace("20261015-main26-gzip-v4", VERSION)
+    require(app.count(BASELINE_CPP_LATEST_STATUS) == 1, "app exact sidecar status guard differs")
+    app = app.replace(BASELINE_CPP_LATEST_STATUS, DSC2_CPP_LATEST_STATUS)
+    app_path.write_text(app)
+    subprocess.run(["node", "--check", str(app_path)], check=True, capture_output=True, text=True)
+    index_path = output / "index.html"
+    index = index_path.read_text()
+    require(index.count("20261015-main26-gzip-v4") == 1, "index cache token differs")
+    index_path.write_text(index.replace("20261015-main26-gzip-v4", VERSION))
+    require(sha256(output / "ranking.js") == sha256(baseline / "ranking.js"), "ranking.js changed")
+
+    readme_path = output / "README.md"
+    readme_path.write_text(readme_path.read_text() + (
+        "\n## DSC2 BOS/REGER reuse\n\nThe 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.\n"
+    ))
+
+    manifest = read_json(output / "manifest.json")
+    data_gz_sha = sha256(output / DATA_GZ)
+    manifest["data_file"] = DATA_GZ
+    manifest["data_sha256"] = data_gz_sha
+    manifest["data_uncompressed_sha256"] = data_sha
+    manifest["counts"] = coverage
+    manifest["measurement_runs"] = data["source"]["measurement_runs"]
+    manifest["cpp135_main26_dsc2_reuse"] = {
+        **run_summary,
+        "evidence": evidence_hashes,
+        "acceptance": {"file": ACCEPTANCE, "sha256": acceptance_sha},
+        "builder": {"file": Path(__file__).name, "sha256": sha256(Path(__file__))},
+    }
+    manifest["data_transport"] = {"file": DATA_GZ, "sha256": data_gz_sha,
+                                  "uncompressed_sha256": data_sha, "encoding": "gzip"}
+    manifest["cpp_latest_view"] = {"file": SIDECAR_GZ, "sha256": sidecar_gz_sha,
+                                   "uncompressed_sha256": sidecar_sha, "encoding": "gzip",
+                                   "schema": sidecar["schema"], "status": sidecar["status"]}
+    manifest["latest_page_inputs"] = {
+        "compact_data": {"file": "ui-data.json", "sha256": ui_sha},
+        "selection_sidecar": copy.deepcopy(manifest["cpp_latest_view"]),
+    }
+    write_json(output / "manifest.json", manifest)
+    shutil.copy2(Path(__file__), output / Path(__file__).name)
+
+    changed = [DATA_GZ, "ui-data.json", SIDECAR_GZ, "app.js", "index.html", "README.md", "manifest.json",
+               *EVIDENCE.values(), ACCEPTANCE, Path(__file__).name]
+    integration = {
+        "schema": "compressionbenchmark-cpp135-dsc2-reuse-site-integration-v3",
+        "status": "passed_not_published", "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "parent_revision": PARENT_HEAD, "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": {"dataset_count": 12, "method_count": 2, "pair_count": 24, "numeric_scope_rows": len(additions)},
+        "files": {name: {"bytes": (output / name).stat().st_size, "sha256": sha256(output / name)} for name in changed},
+        "publication_file_list": changed + [INTEGRATION],
+        "semantic_checks": {
+            "only_exact_24_latest_cpp_pair_decisions_replaced": True,
+            "all_historical_dataset_rows_retained_in_canonical_order": True,
+            "exact_60_new_numeric_scope_rows_appended": True,
+            "successful_176_integer_column_routes_retained": True,
+            "composite_scalar_binary_is_null_and_binary_set_is_complete": True,
+            "same_host_no_cross_host_timing": True,
+            "w1_r3_t1_three_encode_then_three_decode": True,
+            "bitexact_decode_evidence_bound": True,
+            "ranking_js_unchanged": True,
+            "data_ui_sidecar_hash_closure": True,
+            "main26_3510_import_not_replayed": True,
+            "main26_and_dsc2_same_actual_timing_contract": True,
+            "dsc2_route_and_binary_provenance_remains_explicit": True,
+        },
+        "transport": {"data_gzip_sha256": data_gz_sha, "data_uncompressed_sha256": data_sha,
+                      "sidecar_gzip_sha256": sidecar_gz_sha, "sidecar_uncompressed_sha256": sidecar_sha},
+    }
+    write_json(output / INTEGRATION, integration)
+    result = {
+        "status": "passed_not_published", "output": str(output), "parent_revision": PARENT_HEAD,
+        "pair_count": 24, "numeric_rows_added": len(additions), "data_sha256": data_sha,
+        "ui_data_sha256": ui_sha, "sidecar_sha256": sidecar_sha,
+        "manifest_sha256": sha256(output / "manifest.json"),
+        "integration_sha256": sha256(output / INTEGRATION),
+        "publication_files": integration["publication_file_list"],
+    }
+    write_json(Path(__file__).with_name("BUILD_RESULT_V3.json"), result)
+    print(json.dumps(result, 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:818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180
-size 837481
+oid sha256:5069bbcb955fa3ea9b12eb1b8771500eb712d01ed529f9fbec0103b2f906fa9b
+size 851074

data-main26.json.gz

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

dsc2-reuse-column-audit.jsonl.gz

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

dsc2-reuse-column-overlay.jsonl.gz

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

dsc2-reuse-dataset-method-overlay.jsonl.gz

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

dsc2-reuse-retained-integer-columns.jsonl.gz

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

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

manifest.json

@@ -33,7 +33,7 @@
   },
   "counts": {
     "catalog_dataset_count": 164,
-    "configuration_aggregate_row_count": 5906,
+    "configuration_aggregate_row_count": 5914,
     "corrected_five425": {
       "active_method_count": 85,
       "all_na_pair_count": 0,
@@ -75,10 +75,6 @@
       },
       "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
       "dataset_count": 135,
-      "documentation": {
-        "file": "README.md",
-        "sha256": "c89a678703ff26d46f676a8bb807aff3da30c74961c21063ea277307c8e8af99"
-      },
       "dtype_scope_status_counts": {
         "float": {
           "numeric": 1936,
@@ -109,20 +105,6 @@
         "partial_numeric": 629,
         "unsupported": 1352
       },
-      "publication_transport": {
-        "cpp_latest_view": {
-          "encoding": "gzip",
-          "file": "cpp-latest-view-main26.json.gz",
-          "sha256": "818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180",
-          "uncompressed_sha256": "f1aef2f23a0374e43ddde18d5ab2b29095ff344cf9ef4d591cd8037e55958a6e"
-        },
-        "data": {
-          "encoding": "gzip",
-          "file": "data-main26.json.gz",
-          "sha256": "7a00869fc545f1f2cb7a6c7bd2a6f72e12eddc7361edc68925d3b4bd04ac28a8",
-          "uncompressed_sha256": "e7f7a9f294c1a94aec0e8271c62308f499286cbe9bd2333a6fe685f0839cabb2"
-        }
-      },
       "schema": "cpp135-main26-site-import-v1",
       "site_acceptance": {
         "file": "CPP135_MAIN26_SITE_ACCEPTANCE.json",
@@ -130,8 +112,34 @@
       },
       "timing_policy": "same server-192 W1/R3/T1 column contract; column arithmetic mean; full-valid-support Overall/integer/float scopes only"
     },
+    "cpp135_main26_dsc2_reuse": {
+      "acceptance": {
+        "file": "DSC2_REUSE_SITE_ACCEPTANCE.json",
+        "sha256": "64968f6dd5b8402a7fc5e6416d02b4c462dea496ce0cd4e6dac391218632331f"
+      },
+      "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+      "dataset_count": 12,
+      "execution_host": "192.168.99.20",
+      "methods": [
+        "BOS",
+        "REGER"
+      ],
+      "numeric_row_count": 60,
+      "old_results_retained": true,
+      "pair_count": 24,
+      "schema": "cpp135-main26-dsc2-reuse-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",
+        "precision": "charged once per float method-column",
+        "schedule": "one warmup; three encode measurements; then three decode measurements",
+        "threads": 1
+      }
+    },
     "dataset_count": 164,
-    "dataset_result_row_count": 99008,
+    "dataset_result_row_count": 99068,
     "excluded_datasets": [
       "Arade",
       "app_flow",
@@ -167,7 +175,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": 982,
+    "method_configuration_count": 988,
     "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,
@@ -466,7 +474,7 @@
     "native86_unresolved_problem_pair_count": 0,
     "native86_v9_recovered_pair_count": 154,
     "paper_leaderboard_row_count": 0,
-    "runtime_configuration_count": 1630,
+    "runtime_configuration_count": 1636,
     "runtime_count": 14,
     "runtimes": [
       "cpp",
@@ -561,35 +569,83 @@
     },
     "timing_policy": "same server-192 W1/R3/T1 column contract; column arithmetic mean; full-valid-support Overall/integer/float scopes only"
   },
+  "cpp135_main26_dsc2_reuse": {
+    "acceptance": {
+      "file": "DSC2_REUSE_SITE_ACCEPTANCE.json",
+      "sha256": "64968f6dd5b8402a7fc5e6416d02b4c462dea496ce0cd4e6dac391218632331f"
+    },
+    "builder": {
+      "file": "build_dsc2_reuse_site.py",
+      "sha256": "9d5a3a8e2db84f94bde4236f4c7ba4855f53b31db703c3178fda1f25f7a2bf78"
+    },
+    "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+    "dataset_count": 12,
+    "evidence": {
+      "DSC2_REUSE_INDEPENDENT_VERIFICATION.json": {
+        "bytes": 739,
+        "sha256": "3c4c8a705cb26f53e922378508b38c92909396fadc84582a2ff22582d38857c9"
+      },
+      "DSC2_REUSE_OVERLAY_RECEIPT.json": {
+        "bytes": 2358,
+        "sha256": "ff1d11bb0d66ae33c7961c0534981ac6c0240974b6a29a30f9d752c700475f0e"
+      },
+      "DSC2_REUSE_SOURCE_BINDINGS.json": {
+        "bytes": 2676,
+        "sha256": "d73e349d3c500dda077012cb1a33375643df62c379fa9e4f611d5c4d8327f005"
+      },
+      "dsc2-reuse-column-audit.jsonl.gz": {
+        "bytes": 56678,
+        "sha256": "68f41f2addb0fb9c2dea0f6741e5c3d3fce568db3454d1d227faad7fb97fb029"
+      },
+      "dsc2-reuse-column-overlay.jsonl.gz": {
+        "bytes": 142163,
+        "sha256": "3be84e62791a7b6218e58d3d717f2ffd5b3c38e835a8b9f81cec7615237a7e8e"
+      },
+      "dsc2-reuse-dataset-method-overlay.jsonl.gz": {
+        "bytes": 6754,
+        "sha256": "b63ad6ac3e481202d53ea09b17a7c4f3bc340b5dc086b08f8e25cc798603d9db"
+      },
+      "dsc2-reuse-retained-integer-columns.jsonl.gz": {
+        "bytes": 37767,
+        "sha256": "dc539e507ffd03b24d807cc0e69d3b3d86931231ffd6eecdb07686c95f5adbdd"
+      }
+    },
+    "execution_host": "192.168.99.20",
+    "methods": [
+      "BOS",
+      "REGER"
+    ],
+    "numeric_row_count": 60,
+    "old_results_retained": true,
+    "pair_count": 24,
+    "schema": "cpp135-main26-dsc2-reuse-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",
+      "precision": "charged once per float method-column",
+      "schedule": "one warmup; three encode measurements; then three decode measurements",
+      "threads": 1
+    }
+  },
   "cpp_latest_view": {
     "encoding": "gzip",
     "file": "cpp-latest-view-main26.json.gz",
-    "public_packager": {
-      "file": "build_main26_gzip_storage.py",
-      "role": "main26_canonical_json_gzip_packager",
-      "schema": "cpp135-main26-gzip-storage-build-v1",
-      "sha256": "eff8a5fa67dc094e6d85e4d6d7ac54cb6e5643678a23751f1df68545c054549e"
-    },
     "schema": "compressionbenchmark-cpp-latest-view-v1",
-    "sha256": "818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180",
-    "status": "built_from_verified_live_float9_baseline_and_completed_main26",
-    "uncompressed_sha256": "f1aef2f23a0374e43ddde18d5ab2b29095ff344cf9ef4d591cd8037e55958a6e"
+    "sha256": "5069bbcb955fa3ea9b12eb1b8771500eb712d01ed529f9fbec0103b2f906fa9b",
+    "status": "built_from_published_main26_plus_completed_dsc2_reuse",
+    "uncompressed_sha256": "6a083b73b72dd7b93a2cb84bedf852c2df3ee025d0be104c2a1552cdd184dc80"
   },
   "data_file": "data-main26.json.gz",
-  "data_sha256": "7a00869fc545f1f2cb7a6c7bd2a6f72e12eddc7361edc68925d3b4bd04ac28a8",
+  "data_sha256": "1325c3fc08c93cedd8f8714662690fb09586c7460e4110a88a0148544df639b8",
   "data_transport": {
     "encoding": "gzip",
     "file": "data-main26.json.gz",
-    "public_packager": {
-      "file": "build_main26_gzip_storage.py",
-      "role": "main26_canonical_json_gzip_packager",
-      "schema": "cpp135-main26-gzip-storage-build-v1",
-      "sha256": "eff8a5fa67dc094e6d85e4d6d7ac54cb6e5643678a23751f1df68545c054549e"
-    },
-    "sha256": "7a00869fc545f1f2cb7a6c7bd2a6f72e12eddc7361edc68925d3b4bd04ac28a8",
-    "uncompressed_sha256": "e7f7a9f294c1a94aec0e8271c62308f499286cbe9bd2333a6fe685f0839cabb2"
+    "sha256": "1325c3fc08c93cedd8f8714662690fb09586c7460e4110a88a0148544df639b8",
+    "uncompressed_sha256": "39b017fab9ee25ca7758f678d30212ed21d4e8c138de2161daa0b33b530dd376"
   },
-  "data_uncompressed_sha256": "e7f7a9f294c1a94aec0e8271c62308f499286cbe9bd2333a6fe685f0839cabb2",
+  "data_uncompressed_sha256": "39b017fab9ee25ca7758f678d30212ed21d4e8c138de2161daa0b33b530dd376",
   "dataset_catalog_sha256": "47869c8078e8c864810d4f961fa5879e120943bb3f371b39f0adc74f3de2ee2d",
   "excluded_content": [
     "raw datasets",
@@ -634,15 +690,15 @@
   "latest_page_inputs": {
     "compact_data": {
       "file": "ui-data.json",
-      "sha256": "841b15cbef0c346b43d72ab3c9530065abe4d24c45aef64d5e75d8ec49996f8f"
+      "sha256": "8a1f02ce7e55e68f464a7daec6dab8a8c1a12fd632d5b351bb0d4474522570ae"
     },
     "selection_sidecar": {
       "encoding": "gzip",
       "file": "cpp-latest-view-main26.json.gz",
       "schema": "compressionbenchmark-cpp-latest-view-v1",
-      "sha256": "818f9390fbbfe49e3afc1f44330cb612e32848376f158202413ad60097672180",
-      "status": "built_from_verified_live_float9_baseline_and_completed_main26",
-      "uncompressed_sha256": "f1aef2f23a0374e43ddde18d5ab2b29095ff344cf9ef4d591cd8037e55958a6e"
+      "sha256": "5069bbcb955fa3ea9b12eb1b8771500eb712d01ed529f9fbec0103b2f906fa9b",
+      "status": "built_from_published_main26_plus_completed_dsc2_reuse",
+      "uncompressed_sha256": "6a083b73b72dd7b93a2cb84bedf852c2df3ee025d0be104c2a1552cdd184dc80"
     }
   },
   "measurement_runs": [
@@ -1302,6 +1358,32 @@
         "sha256": "e99fdac1f870174c520a2a2fae643ca4259a33afb4feffd0e849a5a302ad91cd"
       },
       "timing_policy": "same server-192 W1/R3/T1 column contract; column arithmetic mean; full-valid-support Overall/integer/float scopes only"
+    },
+    {
+      "acceptance": {
+        "file": "DSC2_REUSE_SITE_ACCEPTANCE.json",
+        "sha256": "64968f6dd5b8402a7fc5e6416d02b4c462dea496ce0cd4e6dac391218632331f"
+      },
+      "comparison_profile": "cpp-native192-main26-whole-column-20261015-v1",
+      "dataset_count": 12,
+      "execution_host": "192.168.99.20",
+      "methods": [
+        "BOS",
+        "REGER"
+      ],
+      "numeric_row_count": 60,
+      "old_results_retained": true,
+      "pair_count": 24,
+      "schema": "cpp135-main26-dsc2-reuse-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",
+        "precision": "charged once per float method-column",
+        "schedule": "one warmup; three encode measurements; then three decode measurements",
+        "threads": 1
+      }
     }
   ],
   "native86_imports": {