Merge latest C++ results and clarify Overall timing coverage

Unify published C++ profiles by dataset and canonical method, selecting the latest authoritative campaign and preserving unsupported/N/A conclusions. Show admitted timed-subset coverage without borrowing old timing. Preserve immutable science payload and ranking formula. Independent source/data reviews and 756 UI regression assertions passed.

.gitattributes

@@ -36,3 +36,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 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

CPP_LATEST_VIEW_INDEPENDENT_MERGE_REVIEW_V1.json

@@ -0,0 +1,42 @@
+{
+  "schema": "compressionbenchmark-cpp-latest-independent-review-v1",
+  "status": "pass",
+  "approved_for_ui_integration": true,
+  "review_source_sha256": "492cfd30139c94734a8a0047f9ead9ffb3aced84fae96fa084c4c858370ecec2",
+  "builder_sha256": "5e403d286a5ffa8669c6ee52deda903cf4487e4dbb1e962c65c224f12a7dbbda",
+  "sidecar_sha256": "5d2a8bb4fb5c38fbc4fa130a08b7608c7568f3959ef9dd2706f245862907f90f",
+  "build_result_sha256": "1a7bf2407c72563454658a4730644c559553d114404f13038182da9680a67810",
+  "check_count": 10,
+  "checks": [
+    "frozen source/output/receipt hashes",
+    "all ten published source inputs match online ledger",
+    "schema, build receipt and explicit alias map",
+    "all selected rows are unique immutable compact references with original provenance",
+    "13,940 active pairs independently reconstruct to the same atomic winning campaigns",
+    "all 425 corrected-five decisions supersede old rows, including 39 tombstones",
+    "canonical aliases remove duplicate legacy families; two evidenced extras remain",
+    "timed subset is exact, admitted and single-contract server-166 main evidence",
+    "terminal tombstones block four old overall datasets; Fresh114 remains pending",
+    "tampered published input and baseline receipt are rejected before output"
+  ],
+  "counts": {
+    "active_native85_pair_conclusions": 13940,
+    "active_native85_numeric_pairs": 11692,
+    "active_native85_pair_status": {
+      "numeric": 11692,
+      "not_applicable": 2209,
+      "unsupported": 39
+    },
+    "active_native85_terminal_tombstone_pairs": 2248,
+    "legacy_extra_pair_count": 35,
+    "selected_compact_row_count": 26834,
+    "timing_admitted_selected_row_count": 24617,
+    "overall_numeric_dataset_count": 160,
+    "overall_numeric_pair_count": 9991
+  },
+  "notes": [
+    "This approves a derived index view, not a new independent measurement claim.",
+    "No timing, rate, byte or status field was synthesized or promoted.",
+    "UI integration must preserve per-row source profile, host, measurement status, timing status and the strict score gate."
+  ]
+}

CPP_LATEST_VIEW_INDEPENDENT_UI_REVIEW_V2.json

@@ -0,0 +1,96 @@
+{
+  "schema": "compressionbenchmark-overall-cpp-latest-ui-independent-review-v2",
+  "status": "PASS",
+  "supersedes_review_receipt_sha256": "a42281dcb141c6b9feb00e6bd8875861b73979d3cbc0a38b5e76378bf04d4573",
+  "checks": 756,
+  "source_sha256": {
+    "app.js": "aff79c2796cceca48e12afcdb3f8d21300897bb272b0e444517a197a714718dc",
+    "availability.js": "d0608c40c7490dbb9881c9a3b22e4af5a4b6af6041fba8cc3a8efbd8061418b5",
+    "index.html": "27a97c650260a382aa77e41df1203c626eca82d9462692d6523b9e372833a6de",
+    "style.css": "6be468cbbed9bdef493ee7a3ce424d45faecb620cb0dbca23cbb5822067f0e71",
+    "README.md": "eb0d0cf52f6d8868deef92dd1b1032f5fb4a5649b23188c1f7e6477f9f014834",
+    "cpp-latest-view.json": "5d2a8bb4fb5c38fbc4fa130a08b7608c7568f3959ef9dd2706f245862907f90f"
+  },
+  "baseline_unchanged_sha256": {
+    "ranking.js": "6e14543b42050ec7ad6a04948e8abd6f3589c477035708f9d01814d05a16c076",
+    "data.json": "b7b542c5731786d0486e89de889f024c7e6f69eacb68a7df67bc00179b07af4c",
+    "ui-data.json": "ef5aa05289f609f2f62ceed009ee17247c8b4767bba8f4aa8cd522ce83d3521d",
+    "manifest.json": "c226349a05d564cfc2498397c30e51308cc8dcfb65df94e9e7927527af955b88"
+  },
+  "legacy_imported_timing_receipt": {
+    "path": "legacy-dbp-medium-posts-timing-receipt.json",
+    "sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324",
+    "status": "passed",
+    "declared_environment_hostname": "server",
+    "published_runtime_host_descriptor": "source snapshot"
+  },
+  "real_fixture": {
+    "catalog_datasets": 164,
+    "cpp_selected_compact_rows": 26834,
+    "cpp_overall_numeric_datasets": 160,
+    "cpp_overall_family_rows": 86,
+    "rate_rows": 86,
+    "strict_timing_rows": 1,
+    "strict_timing_families": [
+      {
+        "method": "BUFF",
+        "coverage": 1,
+        "timed_subset_coverage": 1,
+        "source_profiles": [
+          "cpp-native166-main-458a218f"
+        ],
+        "hosts": [
+          "166"
+        ]
+      }
+    ],
+    "timed_subset_rows": 84,
+    "average_rank_rows": 84,
+    "no_average_rank_families": [
+      "BSS+LZ4",
+      "Sub-column"
+    ],
+    "composite_score_rows": 0,
+    "java_compact_rows": 23884,
+    "python_compact_rows": 17762,
+    "imported_admitted_rows": 4,
+    "imported_profiles": {
+      "java": {
+        "family_rows": 92,
+        "numeric_datasets": 164,
+        "dbp_timed_subset_coverage": 1,
+        "dbp_rate_denominator": 164,
+        "medium_posts_dbp_compression_time": 278.32101832066036,
+        "medium_posts_dbp_decompression_time": 58.34620516102439,
+        "medium_posts_dbp_average_rank": 1,
+        "full_strict_timing_rows": 0,
+        "full_timed_subset_rows": 1,
+        "full_average_rank_rows": 1,
+        "full_composite_rows": 0
+      },
+      "python": {
+        "family_rows": 90,
+        "numeric_datasets": 164,
+        "dbp_timed_subset_coverage": 1,
+        "dbp_rate_denominator": 164,
+        "medium_posts_dbp_compression_time": 1332.4766408868545,
+        "medium_posts_dbp_decompression_time": 2295.383334598822,
+        "medium_posts_dbp_average_rank": 1,
+        "full_strict_timing_rows": 0,
+        "full_timed_subset_rows": 1,
+        "full_average_rank_rows": 1,
+        "full_composite_rows": 0
+      }
+    }
+  },
+  "boundaries": [
+    "latest accepted pair selection is read from the SHA-bound index-only sidecar",
+    "timed-subset rows use only current selected admitted timing from one profile/host/contract",
+    "strict timings and composite scores remain unavailable under incomplete current coverage",
+    "terminal N/A and unsupported decisions are not backfilled from older numeric rows",
+    "pending FreshRetailNet-50K full114 results are excluded",
+    "Java and Python preserve their decoded source profile/runtime and use only the frozen published runtime-host descriptor",
+    "only four receipt-admitted imported rows retain timing; diagnostic imported timings remain unavailable",
+    "ranking.js and frozen data payloads remain byte-identical"
+  ]
+}

CPP_LATEST_VIEW_INTEGRATION_V1.json

@@ -0,0 +1,86 @@
+{
+  "schema": "compressionbenchmark-cpp-latest-view-integration-v1",
+  "status": "validated_view_publication_input",
+  "created_at": "2026-10-13T18:46:52.217252+08:00",
+  "parent_revision": "d84ab7155ac1d2279610facdebe8aae1681b655b",
+  "scope": "Derived C++ latest authoritative campaign selection and availability UI. Immutable published science payload unchanged.",
+  "selection": "One latest admitted published campaign per dataset and canonical method; retain all configurations and scopes of winning campaign; terminal unsupported/N/A suppress older numeric fallback.",
+  "language_options": [
+    "cpp",
+    "java",
+    "python"
+  ],
+  "counts": {
+    "catalog_datasets": 164,
+    "active_native85_pair_conclusions": 13940,
+    "active_native85_numeric_pairs": 11692,
+    "not_applicable_pairs": 2209,
+    "unsupported_pairs": 39,
+    "legacy_extra_pairs": 35,
+    "selected_compact_rows": 26834,
+    "admitted_timing_rows": 24617,
+    "overall_numeric_datasets": 160,
+    "overall_method_families": 86,
+    "overall_families_with_admitted_timed_subset": 84
+  },
+  "timing": "Strict complete timing/composite stay unavailable when incomplete. Separate admitted subset time is explicitly covered N/M and restricted to one source contract/profile/host. Superseded times are never borrowed. Original ranking.js unchanged.",
+  "pending": [
+    "FreshRetailNet-50K corrected 114-column new experiment is not independently accepted and is excluded from this view; last completed old input remains visibly identified."
+  ],
+  "unchanged_science_sha256": {
+    "ranking.js": "6e14543b42050ec7ad6a04948e8abd6f3589c477035708f9d01814d05a16c076",
+    "data.json": "b7b542c5731786d0486e89de889f024c7e6f69eacb68a7df67bc00179b07af4c",
+    "ui-data.json": "ef5aa05289f609f2f62ceed009ee17247c8b4767bba8f4aa8cd522ce83d3521d",
+    "manifest.json": "c226349a05d564cfc2498397c30e51308cc8dcfb65df94e9e7927527af955b88"
+  },
+  "assets": {
+    "README.md": {
+      "bytes": 10350,
+      "sha256": "eb0d0cf52f6d8868deef92dd1b1032f5fb4a5649b23188c1f7e6477f9f014834"
+    },
+    "app.js": {
+      "bytes": 66083,
+      "sha256": "aff79c2796cceca48e12afcdb3f8d21300897bb272b0e444517a197a714718dc"
+    },
+    "index.html": {
+      "bytes": 17532,
+      "sha256": "27a97c650260a382aa77e41df1203c626eca82d9462692d6523b9e372833a6de"
+    },
+    "style.css": {
+      "bytes": 21877,
+      "sha256": "6be468cbbed9bdef493ee7a3ce424d45faecb620cb0dbca23cbb5822067f0e71"
+    },
+    "availability.js": {
+      "bytes": 11264,
+      "sha256": "d0608c40c7490dbb9881c9a3b22e4af5a4b6af6041fba8cc3a8efbd8061418b5"
+    },
+    "cpp-latest-view.json": {
+      "bytes": 19973658,
+      "sha256": "5d2a8bb4fb5c38fbc4fa130a08b7608c7568f3959ef9dd2706f245862907f90f"
+    },
+    "build_cpp_latest_view.py": {
+      "bytes": 31236,
+      "sha256": "5e403d286a5ffa8669c6ee52deda903cf4487e4dbb1e962c65c224f12a7dbbda"
+    },
+    "CPP_LATEST_VIEW_INDEPENDENT_MERGE_REVIEW_V1.json": {
+      "bytes": 2081,
+      "sha256": "51b9c3aea87f6aec836a127be72fdd97815b37b4e974db1a37ad91616f9fb077"
+    },
+    "CPP_LATEST_VIEW_INDEPENDENT_UI_REVIEW_V2.json": {
+      "bytes": 3977,
+      "sha256": "c49ad3033ac519b6c390603d56938d7733f4e8a753501f97cf0922dfe6b35e29"
+    }
+  },
+  "reviews": {
+    "merge": "51b9c3aea87f6aec836a127be72fdd97815b37b4e974db1a37ad91616f9fb077",
+    "ui_v2": "c49ad3033ac519b6c390603d56938d7733f4e8a753501f97cf0922dfe6b35e29",
+    "ui_assertions_passed": 756
+  },
+  "local_browser_qa": {
+    "LOCAL_PAGE_PROOF.json": "756b1de2353d22429f66feee61bc249e71a710557bbd26e82b3424416b2eb327",
+    "LOCAL_OVERALL_CSV_REVIEW.json": "bd85985c44a10e6b0fd96efec7c2fbb3d8ad74fda8a99c331cabe500657e075d",
+    "LOCAL_CORRECTED_PRECEDENCE_CSV_REVIEW.json": "b23b0ebedf597f3870c6f93fb9f24ec4f02cea1c84bf8bb29286511e5d3ddd17",
+    "LOCAL_LEGACY_TIMING_REGRESSION.json": "875b9973afd30176f79392ccb82cfc24aadc5e13c4403f3ab76cb2d593e3690b"
+  },
+  "publication_state": "Not published by this receipt; actual commit and live browser checks recorded separately after publication."
+}

README.md

@@ -48,7 +48,7 @@ The reviewed 164-dataset scope contains 89 directly measured real datasets and 7
 
 ## Interface
 
-- Overall and per-dataset leaderboards with runtime, data-type, precision, family, and method filters
+- Overall and per-dataset leaderboards with C++ / Java / Python, data-type, precision, family, and method filters
 - Sortable metrics, optional columns, and CSV download of the selected ranking
 - Compression rate versus compression/decompression cost plots
 - Dataset-level method details, snapshot provenance, and metric definitions
@@ -57,13 +57,19 @@ The reviewed 164-dataset scope contains 89 directly measured real datasets and 7
 - Overall composite score and average dataset Rank, with 66 valid non-negative one-decimal weight combinations, including zero weights
 - Searchable Methods documentation and a 30-family operator catalog with 102 implementation-directory entries, references, I/O contracts, examples, and status
 
-The summary dataset count and Dataset coverage denominator use the same measured dataset set for the selected comparison profile, data type, and dataset selection; the default Overall view has 164 measured datasets. All 164 reviewed datasets remain searchable and selectable in the dataset browser. Dataset coverage can differ by method and profile; unavailable combinations show **No published measurements**, remain excluded from rankings, and are never converted to zero-valued results. The default family view selects the lowest-rate measured exact variant independently for each dataset only when every candidate for that dataset/family has the same eligible aggregate-id set; it can therefore choose different binaries across datasets. Ambiguous support sets are omitted. Switch to **Exact configuration** to inspect each fixed variant, support hash, source profile, and binary. Native server results use host/campaign/measurement-contract comparison profiles; exact adapter and binary identities remain visible and are never merged into one configuration.
+The summary dataset count and Dataset coverage denominator are derived from the selected language and data scope. The catalog remains 164 datasets; a selected result view can contain fewer numeric datasets because terminal N/A or unsupported conclusions are not converted to measurements. The C++ view uses the latest receipt-bound authority for each logical dataset/method pair. A newer terminal N/A or unsupported conclusion blocks fallback to an older numeric result. Earlier rows remain preserved in the immutable snapshot and evidence files, while method details and CSV retain the selected row's source family, source comparison profile, host, binary and measurement status. The default family view selects the lowest-rate measured exact variant independently for each dataset only when every candidate for that dataset/family has the same eligible aggregate-id set. Ambiguous support sets are omitted. Switch to **Exact configuration** to inspect fixed variants and provenance.
 
 The Overall score is `a × average rate + b × normalized average compression time + c × normalized average decompression time`. It is available only when displayed methods share one exact dataset/support signature. Average Rank compares methods within each matching `(dataset, eligible aggregate-id set)` cohort, applies dataset-local time normalization and fractional ties, then averages the available ranks. Missing, N/A, failed, and unlike-support rows are omitted. Coverage and candidate counts can differ; method details expose support hashes, dataset scores, ranks and candidate counts. CSV downloads include weights, support hashes, evidence status and rank coverage. The default weights are `a=0.4, b=0.3, c=0.3`.
 
-Compression and decompression costs are calculated independently for each usable numeric column as ns/point, then reported as the arithmetic mean across those columns; each column contributes equally. Overall timing pools all measured columns across the selected datasets when every selected dataset has column-level evidence. If any selected dataset/configuration is backed only by aggregate timing, the method uses an arithmetic mean of its selected per-dataset ns/point values, giving every dataset equal weight. Aggregate-only dataset timing uses recorded elapsed time divided by recorded points; these records keep a zero measured-column count. Truly missing measurements remain unavailable. Method details and CSV expose the timing basis. Native-float measurements use valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Timing comparisons stay within the same host/campaign/measurement-contract comparison profile. Finite source timings with only diagnostic provenance are published as unavailable and cannot enter time or composite rankings.
+Compression and decompression costs are calculated independently for each usable numeric column as ns/point, then reported as the arithmetic mean across those columns; each column contributes equally. Strict timing is available only when every current rate dataset for that method has admitted timing under one valid workload. A separately labeled **timed subset** is shown when the current winning rows include admitted timing for only N of M rate datasets, and only when all N rows share one exact source profile, host and timing contract. The N/M coverage is displayed inline and exported to CSV. Timed-subset values never enter strict composite scores. Finite source timings with diagnostic or unbound provenance remain unavailable and are not borrowed from superseded rows.
 
-The server-166 terminal matrix contains all `164 × 85 = 13,940` dataset/method pairs: 11,164 main pairs have at least one numeric aggregate, 2,274 are explicit N/A, and 502 ended with problems. Current V9 contributes receipt/result/cold-SHA-bound rate and byte replacements for 154 problem identities. Server 192 contributes 21 independently pair-verified replacements; one (`weather_data_bavaria/LZG`) overlaps V9. The union therefore repairs 174 problem identities and leaves 328 unresolved, including the separately scheduled `wids2023_competition_weather_forecasting/Shrinker` sidecar. Only result rows with `status=ok` and matching fresh-cold evidence enter numeric views; mixed-support pairs have no overall row. The old main profile's timing is admitted by a frozen source/build/binary/boundary proof. V9 and server-192 timings remain unavailable until their exact variants receive independent source/build/timing-boundary proof. Legacy source-snapshot timings with unspecified host or build boundary are also unavailable to timing and composite rankings; the six receipt-bound DBP `medium_posts` rows retain admitted timing. Server-192 results remain separate from server 166.
+The server-166 terminal matrix contains all `164 × 85 = 13,940` dataset/method pairs. Later independently reviewed recovery, completion and corrected-input receipts can supersede those base pair results. The combined C++ rate view does not average timings across servers or campaigns. Main-profile timing is admitted by a frozen source/build/binary/boundary proof; recovery timing remains unavailable without the same proof. Source environments and original measurement statuses remain explicit provenance fields.
+
+Java and Python rows retain their original comparison profile and use the explicit runtime host label already stored in the frozen browser payload. This metadata is never inferred from the selected UI language. The receipt-bound `medium_posts` DBP records keep their admitted timing; other imported timings remain diagnostic and unavailable to strict timing or composite scoring.
+
+## Combined C++ latest-result view
+
+`cpp-latest-view.json` is an index-only, SHA-bound selection sidecar. It stores no copied or transformed measurement values. The frozen sidecar SHA-256 is `5d2a8bb4fb5c38fbc4fa130a08b7608c7568f3959ef9dd2706f245862907f90f`; it selects 26,834 compact rows, including 24,617 admitted-timing rows from one main-server timing contract. Each selected C++ row refers to an integer index in the unchanged `ui-data.json` compact table and records its canonical family, original family, source profile, runtime, host, authority and pair status. Pair-level campaign selection is atomic, so scopes absent from a newer winning campaign are tombstoned instead of backfilled from an older campaign. The browser verifies the sidecar SHA, frozen payload SHA, source-data SHA, index bounds, uniqueness, source family, language boundary and timing-admission index before rendering. A mismatch fails closed. FreshRetailNet-50K corrected full114 remains pending and is not represented as a newer accepted campaign.
 
 The independent evidence review covers 773 archived strict-admission pairs. Its 147 non-adjudicated entries belong to the earlier 920-pair recovery bundle and retain the explicit `partial_verification_blocked` status; the site does not generalize that review to all 13,940 terminal pairs.
 

app.js

@@ -1,11 +1,12 @@
 import {WEIGHT_TENTHS,parseWeights,addRankingMetrics} from './ranking.js?v=20261011-support-matched-v1';
+import {DEFAULT_PROFILE,profileLabel,defaultColumnVisible,metricAvailability,summarizeAvailability,visibleColumns,profileScopeText,aggregateTimedSubset,strictTimingMode} from './availability.js?v=20261013-overall-availability-v3';
+const CPP_LATEST_VIEW_SHA256='5d2a8bb4fb5c38fbc4fa130a08b7608c7568f3959ef9dd2706f245862907f90f';
 const $ = (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;
 const mean = (values) => { const a = values.map(number).filter((n) => n !== null); return a.length ? a.reduce((s,n) => s+n,0)/a.length : null; };
 function timingMode(input) {
-  if(!input.length||input.some(r=>number(r.compression_time)===null||number(r.decompression_time)===null||!Number.isInteger(r.timing_column_count)||r.timing_column_count<0||!((r.timing_aggregation==='column_mean'&&r.timing_column_count>0)||(r.timing_aggregation==='dataset_aggregate'&&r.timing_column_count===0))))return 'unavailable';
-  return input.some(r=>r.timing_aggregation==='dataset_aggregate')?'dataset_mean':'column_mean';
+  return strictTimingMode(input);
 }
 function aggregateTime(input,key) {
   const mode=timingMode(input);
@@ -13,33 +14,38 @@ function aggregateTime(input,key) {
   if(mode==='dataset_mean')return mean(input.map(r=>r[key]));
   return input.reduce((sum,r)=>sum+r[key]*r.timing_column_count,0)/input.reduce((sum,r)=>sum+r.timing_column_count,0);
 }
-const timingLabel=mode=>({column_mean:'Equal-column arithmetic mean',dataset_mean:'Equal-dataset arithmetic mean',dataset_aggregate:'Dataset aggregate',unavailable:'Not reported'}[mode]??'Not reported');
-const fmt = (v, digits=3) => number(v) === null ? 'Not reported' : Number(v).toLocaleString('en-US',{maximumFractionDigits:digits,minimumFractionDigits:digits});
+const timingLabel=mode=>({column_mean:'Equal-column arithmetic mean',dataset_mean:'Equal-dataset arithmetic mean',dataset_aggregate:'Dataset aggregate',unavailable:'Unavailable'}[mode]??'Unavailable');
+const fmt = (v, digits=3) => number(v) === null ? 'Unavailable' : Number(v).toLocaleString('en-US',{maximumFractionDigits:digits,minimumFractionDigits:digits});
 const countFmt = (v) => Number(v).toLocaleString('en-US');
-const runtimeName = (v) => snapshot?.benchmark?.runtime_labels?.[v] || ({cpp:'C++',java:'Java',python:'Python','cpp-native166':'Native C++ · server 166','cpp-native192':'Native C++ · server 192'}[v] || v);
-const runtimeHost = (v) => snapshot?.benchmark?.runtime_hosts?.[v] || ({'cpp-native166':'166','cpp-native192':'192'}[v] || 'source snapshot');
+const runtimeName = (v) => profileLabel(v,snapshot?.benchmark?.runtime_labels?.[v] || ({cpp:'C++',java:'Java',python:'Python','cpp-native166':'Native C++ · server 166','cpp-native192':'Native C++ · server 192'}[v] || v));
+const runtimeHost = (v) => v==='cpp'?'multiple source environments; see per-dataset provenance':snapshot?.benchmark?.runtime_hosts?.[v] || ({'cpp-native166':'166','cpp-native192':'192'}[v] || 'source snapshot');
 const THULAB_DATASET_PREFIX='https://huggingface.co/datasets/THULab/';
 const requestedDataset=new URLSearchParams(location.search).get('dataset')?.trim()||'';
 let requestedDatasetApplied=false;
 const cols = [
-  {key:'average_rank',label:'Average Rank ↓',digits:2,visible:true,overallOnly:true},
-  {key:'rank_coverage',label:'Rank coverage',digits:0,visible:false,overallOnly:true},
-  {key:'composite_score',label:'Composite score ↓',digits:4,visible:true,overallOnly:true},
-  {key:'compression_rate',label:'Average rate ↓',digits:4,visible:true},
-  {key:'overall_rate',label:'Overall rate ↓',digits:4,visible:false},
-  {key:'compression_time',label:'Compress ns/point ↓',digits:2,visible:true},
-  {key:'decompression_time',label:'Decompress ns/point ↓',digits:2,visible:true},
-  {key:'normalized_compression_time',label:'Normalized compress ↓',digits:4,visible:false,overallOnly:true},
-  {key:'normalized_decompression_time',label:'Normalized decompress ↓',digits:4,visible:false,overallOnly:true},
-  {key:'timing_column_count',label:'Measured columns',digits:0,visible:false},
-  {key:'compressed_bytes',label:'Compressed bytes',digits:0,visible:false},
-  {key:'original_bytes',label:'Original bytes',digits:0,visible:false},
+  {key:'average_rank',label:'Average Rank ↓',digits:2,visible:true,defaultVisible:true,overallOnly:true},
+  {key:'rank_coverage',label:'Rank coverage',digits:0,visible:true,defaultVisible:true,overallOnly:true},
+  {key:'composite_score',label:'Composite score ↓',digits:4,visible:true,defaultVisible:true,overallOnly:true},
+  {key:'compression_rate',label:'Average rate ↓',digits:4,visible:true,defaultVisible:true},
+  {key:'overall_rate',label:'Overall rate ↓',digits:4,visible:false,defaultVisible:false},
+  {key:'compression_time',label:'Compress ns/point ↓',digits:2,visible:true,defaultVisible:true},
+  {key:'decompression_time',label:'Decompress ns/point ↓',digits:2,visible:true,defaultVisible:true},
+  {key:'compression_time_timed_subset',label:'Compress ns/point · timed subset ↓',digits:2,visible:true,defaultVisible:true},
+  {key:'decompression_time_timed_subset',label:'Decompress ns/point · timed subset ↓',digits:2,visible:true,defaultVisible:true},
+  {key:'normalized_compression_time',label:'Normalized compress ↓',digits:4,visible:false,defaultVisible:false,overallOnly:true},
+  {key:'normalized_decompression_time',label:'Normalized decompress ↓',digits:4,visible:false,defaultVisible:false,overallOnly:true},
+  {key:'timing_column_count',label:'Measured columns',digits:0,visible:false,defaultVisible:false},
+  {key:'compressed_bytes',label:'Compressed bytes',digits:0,visible:false,defaultVisible:false},
+  {key:'original_bytes',label:'Original bytes',digits:0,visible:false,defaultVisible:false},
 ];
 let snapshot, records=[], methods=new Map(), datasets=new Map(), currentRows=[], activeTab='overall';
+let cppLatestView=null;
 let referenceCatalog=null,referenceCatalogError=null,datasetCatalog=null,datasetCatalogError=null;
 let operatorEffect=null,operatorEffectError=null;
 let sort={key:'compression_rate',direction:1};
 let selectedMethod=null;
+const touchedColumns=new Set();
+let legacyProfileRequested='';
 const state = () => ({runtime:$('runtime').value,dataset:$('dataset').value,dtype:$('dtype').value,precision:$('precision').value,family:$('family').value,mode:$('row-mode').value,search:$('search').value.trim().toLowerCase(),complete:$('complete-only').checked});
 function scopeKey() { const s=state(); return s.dtype==='overall'?'overall':s.dtype==='int'?'integer':s.precision==='fixed'?'fixed_float':s.precision==='non_fixed'?'nonfixed_float':'float'; }
 function normalizeRecord(r) {
@@ -62,6 +68,13 @@ function filteredRecords(ignoreMethod=false) {
   return ignoreMethod?result:result.filter(r=>(s.family==='all'||r.family===s.family)&&(!s.search||(s.mode==='family'?r.family:`${r.method} ${r.family}`).toLowerCase().includes(s.search)));
 }
 function coverageDatasetCount() { return new Set(filteredRecords(true).map(r=>r.dataset)).size; }
+function populateFamilyControl() {
+  const control=$('family');if(!control)return;
+  const selected=control.value,scope=scopeKey(),runtime=$('runtime').value;
+  const families=[...new Set(records.filter(record=>record.runtime===runtime&&record.scope===scope).map(record=>record.family))].sort((a,b)=>a.localeCompare(b));
+  control.innerHTML='<option value="all">All method families</option>'+families.map(family=>`<option value="${escape(family)}">${escape(family)}</option>`).join('');
+  control.value=families.includes(selected)?selected:'all';
+}
 function aggregate(input) {
   const groups=new Map();
   const exact=state().mode==='configuration',familiesByConfiguration=new Map();
@@ -73,25 +86,50 @@ function aggregate(input) {
     const configuration=source[0].method,method=exact&&familiesByConfiguration.get(configuration).size>1?`${source[0].family} · ${configuration}`:configuration;
     const hasBytes=source.every(r=>r.original_bytes!==null && r.original_bytes>0 && r.compressed_bytes!==null && r.compressed_bytes>0);
     const original=hasBytes?source.reduce((s,r)=>s+r.original_bytes,0):null, compressed=hasBytes?source.reduce((s,r)=>s+r.compressed_bytes,0):null;
-    rows.push({method,family:source[0].family,runtime:source[0].runtime,compression_rate:mean(source.map(r=>r.compression_rate)),compression_time:aggregateTime(source,'compression_time'),decompression_time:aggregateTime(source,'decompression_time'),timing_column_count:source.reduce((sum,r)=>sum+r.timing_column_count,0),timing_aggregation:timingMode(source),overall_rate:hasBytes?compressed/original:null,original_bytes:original,compressed_bytes:compressed,coverage:new Set(source.map(r=>r.dataset)).size,totalDatasets,source});
+    const timedSubset=aggregateTimedSubset(source);
+    rows.push({method,family:source[0].family,runtime:source[0].runtime,compression_rate:mean(source.map(r=>r.compression_rate)),compression_time:aggregateTime(source,'compression_time'),decompression_time:aggregateTime(source,'decompression_time'),timing_column_count:source.reduce((sum,r)=>sum+(Number.isInteger(r.timing_column_count)?r.timing_column_count:0),0),timing_aggregation:timingMode(source),overall_rate:hasBytes?compressed/original:null,original_bytes:original,compressed_bytes:compressed,coverage:new Set(source.map(r=>r.dataset)).size,totalDatasets,source,...timedSubset});
   }
   const s=state();
-  return addRankingMetrics(rows,parseWeights($('weights').value)).filter(r=>(s.family==='all'||r.family===s.family)&&(!s.search||(s.mode==='family'?r.family:`${r.method} ${r.family}`).toLowerCase().includes(s.search))&&(!s.complete||r.coverage===totalDatasets)).sort((a,b)=>{
+  return addRankingMetrics(rows,parseWeights($('weights').value)).map(row=>row.normalization_reference_rows>=2?row:{...row,normalized_compression_time:null,normalized_decompression_time:null,composite_score:null}).filter(r=>(s.family==='all'||r.family===s.family)&&(!s.search||(s.mode==='family'?r.family:`${r.method} ${r.family}`).toLowerCase().includes(s.search))&&(!s.complete||r.coverage===totalDatasets)).sort((a,b)=>{
     const av=number(a[sort.key]),bv=number(b[sort.key]);
     if(av===null&&bv===null)return a.method.localeCompare(b.method);
     if(av===null)return 1;if(bv===null)return -1;
     return sort.direction*(av-bv)||a.method.localeCompare(b.method);
   });
 }
+function requestedColumns() {
+  const profile=state().runtime;
+  return cols.filter(column => touchedColumns.has(column.key)?column.visible:defaultColumnVisible(profile,column));
+}
+function syncColumnOptions() {
+  for(const input of $('column-options').querySelectorAll('input')){
+    const column=cols.find(item=>item.key===input.dataset.column);
+    input.checked=touchedColumns.has(column.key)?column.visible:defaultColumnVisible(state().runtime,column);
+  }
+}
+function metricCell(row,column) {
+  if(column.key==='rank_coverage'&&number(row[column.key])!==null)return `${row.rank_coverage} / ${row.totalDatasets}`;
+  if(number(row[column.key])!==null){
+    const subset=['compression_time_timed_subset','decompression_time_timed_subset'].includes(column.key);
+    return `${fmt(row[column.key],column.digits)}${subset?` <span class="metric-coverage" title="Timed subset coverage">${row.timing_subset_coverage} / ${row.timing_subset_denominator}</span>`:''}`;
+  }
+  const unavailable=metricAvailability(row,column.key);
+  return `<span class="unavailable-value" title="${escape(unavailable.detail)}">${escape(unavailable.short)}</span>`;
+}
 function renderTable() {
-  const visible=cols.filter(c=>c.visible&&(!c.overallOnly||activeTab==='overall'));
+  const eligibleColumns=cols.filter(c=>!c.overallOnly||activeTab==='overall');
+  const visible=visibleColumns(eligibleColumns,currentRows,state().runtime,$('show-unavailable-columns').checked,touchedColumns);
   $('leaderboard').querySelector('thead').innerHTML=`<tr><th>Position</th><th>Method / configuration</th>${visible.map(c=>`<th aria-sort="${sort.key===c.key?(sort.direction===1?'ascending':'descending'):'none'}"><button data-sort="${c.key}" title="Sort ${escape(c.label)}">${escape(c.label)}${sort.key===c.key?(sort.direction===1?' ▴':' ▾'):''}</button></th>`).join('')}<th>Dataset coverage</th></tr>`;
   const minima=Object.fromEntries(visible.map(c=>[c.key,Math.min(...currentRows.map(r=>number(r[c.key])).filter(n=>n!==null))]));
-  $('leaderboard').querySelector('tbody').innerHTML=currentRows.length?currentRows.map((r,i)=>`<tr><td class="rank numeric">${i+1}</td><td><button class="method-button" data-method="${escape(r.method)}">${escape(r.method)}</button><span class="method-family">${escape(r.family)} · ${escape(runtimeName(r.runtime))}</span></td>${visible.map(c=>`<td class="numeric ${!['compressed_bytes','original_bytes','rank_coverage','timing_column_count'].includes(c.key)&&number(r[c.key])!==null&&r[c.key]===minima[c.key]?'best':''}">${c.key==='rank_coverage'?`${r.rank_coverage} / ${r.totalDatasets}`:fmt(r[c.key],c.digits)}</td>`).join('')}<td><span class="coverage ${r.coverage===r.totalDatasets?'full':''}">${r.coverage} / ${r.totalDatasets}</span></td></tr>`).join(''):`<tr><td colspan="${visible.length+3}" class="empty-cell">No measurements match this selection. Try another runtime, data type, or dataset.</td></tr>`;
+  $('leaderboard').querySelector('tbody').innerHTML=currentRows.length?currentRows.map((r,i)=>`<tr><td class="rank numeric">${i+1}</td><td><button class="method-button" data-method="${escape(r.method)}">${escape(r.method)}</button><span class="method-family">${escape(r.family)} · ${escape(runtimeName(r.runtime))}</span></td>${visible.map(c=>`<td class="numeric ${!['compressed_bytes','original_bytes','rank_coverage','timing_column_count'].includes(c.key)&&number(r[c.key])!==null&&r[c.key]===minima[c.key]?'best':''}">${metricCell(r,c)}</td>`).join('')}<td><span class="coverage ${r.coverage===r.totalDatasets?'full':''}">${r.coverage} / ${r.totalDatasets}</span></td></tr>`).join(''):`<tr><td colspan="${visible.length+3}" class="empty-cell">No measurements match this selection. Try another runtime, data type, or dataset.</td></tr>`;
   for(const button of $('leaderboard').querySelectorAll('[data-sort]'))button.addEventListener('click',()=>{const key=button.dataset.sort;sort={key,direction:sort.key===key?-sort.direction:1};refresh();});
   for(const button of $('leaderboard').querySelectorAll('[data-method]'))button.addEventListener('click',()=>showMethod(button.dataset.method,true));
   $('row-count').textContent=`${currentRows.length} ${state().mode==='family'?'method families':'method configurations'} · sorted by ${cols.find(c=>c.key===sort.key)?.label??sort.key}`;
   $('download').disabled=!currentRows.length;
+  const availability=summarizeAvailability(currentRows,requestedColumns());
+  const visibleKeys=new Set(visible.map(column=>column.key)),hiddenLabels=requestedColumns().filter(column=>!visibleKeys.has(column.key)).map(column=>column.label.replace(' ↓',''));
+  const timedSubsetRows=currentRows.filter(row=>number(row.compression_time_timed_subset)!==null&&number(row.decompression_time_timed_subset)!==null).length;
+  $('availability-summary').textContent=`Availability: ${availability.parts.join(' · ')} · ${timedSubsetRows}/${availability.total} timed-subset rows (each cell shows timed datasets / current rate datasets).${availability.reasons.length?` ${availability.reasons.join('; ')}.`:''}${hiddenLabels.length&&!$('show-unavailable-columns').checked?` Hidden columns without complete row coverage: ${hiddenLabels.join(', ')}. Use “Show unavailable metric columns” to inspect their explicit reasons.`:''}`;
 }
 function refresh() {
   if(!snapshot)return;
@@ -105,13 +143,17 @@ function refresh() {
     $('results-note').textContent=`All-float measurements are not available in this snapshot. Select a precision category. ${columnCoverageNote}`;
   } else $('results-note').textContent=`${state().mode==='family'?'Each family uses its lowest-rate measured configuration only when that dataset/family has one exact support set; ambiguous support sets are omitted. Configurations may differ across datasets; use Exact configuration for fixed parameters.':'Each row retains one exact configuration and its eligible support-set hash. Lower compression rates and lower ns/point are better.'} ${columnCoverageNote}`;
   currentRows=aggregate(filteredRecords(true));
+  syncColumnOptions();
   const weights=parseWeights($('weights').value);
-  const comparable=currentRows.length&&currentRows.every(r=>r.workload_signature_count<=1);
-  $('score-note').textContent=`Score = ${weights[0].toFixed(1)} × average rate + ${weights[1].toFixed(1)} × normalized compress + ${weights[2].toFixed(1)} × normalized decompress. Lower is better. ${comparable?'Composite scores use one shared dataset/support signature.':'Composite scores are withheld because the displayed methods do not share one exact dataset/support signature.'} Average Rank is computed only among rows with the same dataset and eligible aggregate-id support hash; ties share their average position. Missing, N/A, failed, and unlike-support results receive no rank. Compare rank coverage and inspect method details.`;
+  const scoreAvailability=summarizeAvailability(currentRows,cols);
+  const scoreStatus=!currentRows.length?'No candidate rows are visible; comparability is not inferred.':scoreAvailability.counts.composite_score===currentRows.length?'Composite scores use one complete exact dataset/support signature.':`Composite scores are withheld: ${scoreAvailability.reasons.length?scoreAvailability.reasons.join('; '):'a complete eligible normalization cohort is unavailable'}.`;
+  $('score-note').textContent=`Score = ${weights[0].toFixed(1)} × average rate + ${weights[1].toFixed(1)} × normalized compress + ${weights[2].toFixed(1)} × normalized decompress. Lower is better. ${scoreStatus} Average Rank is computed only among rows with the same dataset and eligible aggregate-id support hash; ties share their average position. Missing, N/A, failed, and unlike-support results receive no rank.`;
   const s=state(),scope=scopeKey(),measuredCount=coverageDatasetCount(),ds=s.dataset==='all'?`all ${measuredCount} measured datasets`:datasetDisplayName(s.dataset);
   $('dataset-count').textContent=countFmt(measuredCount);$('dataset-count-label').textContent='measured datasets';
+  $('method-count').textContent=countFmt(new Set(records.filter(record=>record.runtime===s.runtime&&record.scope===scope).map(record=>record.family)).size);
   const names={overall:'available numeric measurements',integer:'integer columns',float:'floating-point columns',fixed_float:'fixed-precision float columns',nonfixed_float:'non-fixed-precision float columns'};
   $('selection-summary').textContent=`${runtimeName(s.runtime)} · ${names[scope]||scope} · ${ds} · ${currentRows.length} methods`;
+  $('profile-scope-note').textContent=profileScopeText({profile:s.runtime,measuredDatasets:measuredCount,catalogDatasets:datasetEntries().length})+(legacyProfileRequested?` The requested historical profile “${legacyProfileRequested}” is now included in the combined C++ view; this is not an environment-specific view.`:'');
   $('view-title').textContent=activeTab==='dataset'?`${s.dataset==='all'?'Dataset':datasetDisplayName(s.dataset)} leaderboard`:activeTab==='tradeoffs'?'Storage and execution trade-offs':'Overall leaderboard';
   const selectedEntry=s.dataset==='all'?null:datasets.get(s.dataset),selectedDatasetUrl=thulabDatasetUrl(selectedEntry),selectedBadge=$('selected-dataset-badge');
   selectedBadge.hidden=!selectedDatasetUrl;
@@ -138,12 +180,14 @@ function showMethod(method,focus=false) {
   if(!row){selectedMethod=null;detail.hidden=true;return;}selectedMethod=method;
   const meta=methods.get(method)??methods.get(row.source[0].configuration), pipeline=meta?.operator_pipeline;
   const source=row.source.slice().sort((a,b)=>a.dataset.localeCompare(b.dataset));
-  detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${fmt(row.compression_time,2)}</strong><span>Compress ns/point</span></div><div><strong>${fmt(row.decompression_time,2)}</strong><span>Decompress ns/point</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${pipeline?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}<p class="muted">Timing average: ${escape(timingLabel(row.timing_aggregation))}. Dataset metrics below come from the published result files. Measurement boundaries, matched support-set hashes, source hashes, and available verification evidence are recorded in the manifest.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Rate ↓</th><th>Compress ns/point ↓</th><th>Decompress ns/point ↓</th><th>Timing basis</th><th>Measurement evidence</th><th>Timing profile</th><th>Source profile / binary</th><th>Support set</th><th>Original bytes</th><th>Compressed bytes</th><th>Dataset score ↓</th><th>Dataset Rank ↓</th><th>Rank candidates</th></tr></thead><tbody>${source.map(r=>`<tr><td>${escape(r.dataset)}</td><td>${escape(r.configuration)}</td><td class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${fmt(r.compression_time,2)}</td><td class="numeric">${fmt(r.decompression_time,2)}</td><td>${escape(timingLabel(r.timing_aggregation))}</td><td>${escape(r.measurement_status)}</td><td>${escape(r.timing_profile_status)}</td><td class="source-code">${escape(r.source_runtime)} / ${escape(String(r.binary_sha256).slice(0,16))}</td><td class="source-code">${escape(String(r.eligible_column_set_sha256).slice(0,16))}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${fmt(r.dataset_score,4)}</td><td class="numeric">${fmt(r.dataset_rank,2)}</td><td class="numeric">${fmt(r.dataset_candidate_count,0)}</td></tr>`).join('')}</tbody></table></div>`;
+  const strictCompress=metricCell(row,cols.find(column=>column.key==='compression_time')),strictDecompress=metricCell(row,cols.find(column=>column.key==='decompression_time')),subsetCompress=metricCell(row,cols.find(column=>column.key==='compression_time_timed_subset')),subsetDecompress=metricCell(row,cols.find(column=>column.key==='decompression_time_timed_subset'));
+  detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${strictCompress}</strong><span>strict Compress ns/point</span></div><div><strong>${strictDecompress}</strong><span>strict Decompress ns/point</span></div><div><strong>${subsetCompress}</strong><span>Compress ns/point · timed subset</span></div><div><strong>${subsetDecompress}</strong><span>Decompress ns/point · timed subset</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${pipeline?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}<p class="muted">Strict timing average: ${escape(timingLabel(row.timing_aggregation))}. Timed-subset values are shown only when every included timing row has one exact source profile, host, and timing contract; they never enter strict composite scores. Dataset metrics below retain the winning row's source family, profile, and host.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Source family</th><th>Rate ↓</th><th>Compress ns/point ↓</th><th>Decompress ns/point ↓</th><th>Timing basis</th><th>Measurement evidence</th><th>Timing profile</th><th>Selected source profile / host</th><th>Runtime / binary</th><th>Support set</th><th>Original bytes</th><th>Compressed bytes</th><th>Dataset score ↓</th><th>Dataset Rank ↓</th><th>Rank candidates</th></tr></thead><tbody>${source.map(r=>`<tr><td>${escape(r.dataset)}</td><td>${escape(r.configuration)}</td><td>${escape(r.source_family??r.family)}</td><td class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${metricCell(r,cols.find(column=>column.key==='compression_time'))}</td><td class="numeric">${metricCell(r,cols.find(column=>column.key==='decompression_time'))}</td><td>${escape(timingLabel(r.timing_aggregation))}</td><td>${escape(r.measurement_status)}</td><td>${escape(r.timing_profile_status)}</td><td class="source-code">${escape(r.source_comparison_profile??r.runtime)} / ${escape(r.source_execution_host??'source snapshot')}</td><td class="source-code">${escape(r.source_runtime)} / ${escape(String(r.binary_sha256).slice(0,16))}</td><td class="source-code">${escape(String(r.eligible_column_set_sha256).slice(0,16))}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${metricCell(r,{key:'dataset_score',digits:4})}</td><td class="numeric">${metricCell(r,{key:'dataset_rank',digits:2})}</td><td class="numeric">${fmt(r.dataset_candidate_count,0)}</td></tr>`).join('')}</tbody></table></div>`;
   detail.hidden=false;$('close-detail').addEventListener('click',()=>{detail.hidden=true;selectedMethod=null;});
   if(focus){detail.scrollIntoView({block:'nearest',behavior:'auto'});detail.focus({preventScroll:true});}
 }
 function renderChart() {
   const metric=$('chart-metric').value;
+  const compressionMetric=metric.startsWith('compression'),subsetMetric=metric.includes('timed_subset');
   const valid=currentRows.filter(r=>r.compression_rate>0&&r[metric]>0);
   if(!valid.length){$('chart').innerHTML='<p class="chart-empty muted">No positive measurements to plot for this selection.</p>';return;}
   const width=1100,height=410,pad={left:85,right:35,top:30,bottom:65};
@@ -153,16 +197,16 @@ function renderChart() {
   let graph='';
   for(let i=0;i<=5;i++){const rate=maxRate*i/5,px=x(rate);graph+=`<line class="gridline" x1="${px}" y1="${pad.top}" x2="${px}" y2="${height-pad.bottom}"/><text class="axis-label" x="${px}" y="${height-pad.bottom+25}" text-anchor="middle">${fmt(rate,2)}</text>`;}
   for(let i=minLog;i<=maxLog;i++){const n=10**i,py=y(n);graph+=`<line class="gridline" x1="${pad.left}" y1="${py}" x2="${width-pad.right}" y2="${py}"/><text class="axis-label" x="${pad.left-12}" y="${py+4}" text-anchor="end">${n.toLocaleString('en-US',{maximumFractionDigits:3})}</text>`;}
-  for(const r of valid)graph+=`<circle class="point" tabindex="0" role="button" aria-label="${escape(r.method)}: compression rate ${fmt(r.compression_rate,4)}, ${metric==='compression_time'?'compression':'decompression'} ${fmt(r[metric],2)} ns per point" data-method="${escape(r.method)}" cx="${x(r.compression_rate)}" cy="${y(r[metric])}" r="6"><title>${escape(r.method)} | rate ${fmt(r.compression_rate,4)} | ${fmt(r[metric],2)} ns/point | coverage ${r.coverage}/${r.totalDatasets}</title></circle>`;
-  graph+=`<text class="axis-label" x="${width/2}" y="${height-13}" text-anchor="middle">Average compression rate (compressed / original) ↓</text><text class="axis-label" transform="translate(20 ${height/2}) rotate(-90)" text-anchor="middle">${metric==='compression_time'?'Compress':'Decompress'} ns/point (log scale) ↓</text>`;
-  $('chart').innerHTML=`<svg viewBox="0 0 ${width} ${height}" role="img" aria-label="Measured compression rates versus ${metric==='compression_time'?'compression':'decompression'} cost">${graph}</svg>`;
+  for(const r of valid)graph+=`<circle class="point" tabindex="0" role="button" aria-label="${escape(r.method)}: compression rate ${fmt(r.compression_rate,4)}, ${compressionMetric?'compression':'decompression'} ${fmt(r[metric],2)} ns per point${subsetMetric?`, timed subset ${r.timing_subset_coverage} of ${r.timing_subset_denominator} datasets`:''}" data-method="${escape(r.method)}" cx="${x(r.compression_rate)}" cy="${y(r[metric])}" r="6"><title>${escape(r.method)} | rate ${fmt(r.compression_rate,4)} | ${fmt(r[metric],2)} ns/point | ${subsetMetric?`timed subset ${r.timing_subset_coverage}/${r.timing_subset_denominator}`:`coverage ${r.coverage}/${r.totalDatasets}`}</title></circle>`;
+  graph+=`<text class="axis-label" x="${width/2}" y="${height-13}" text-anchor="middle">Average compression rate (compressed / original) ↓</text><text class="axis-label" transform="translate(20 ${height/2}) rotate(-90)" text-anchor="middle">${compressionMetric?'Compress':'Decompress'} ns/point${subsetMetric?' · timed subset':''} (log scale) ↓</text>`;
+  $('chart').innerHTML=`<svg viewBox="0 0 ${width} ${height}" role="img" aria-label="Measured compression rates versus ${compressionMetric?'compression':'decompression'} cost${subsetMetric?' for a timing-admitted subset':''}">${graph}</svg>`;
   for(const p of $('chart').querySelectorAll('[data-method]')){p.addEventListener('click',()=>showMethod(p.dataset.method,true));p.addEventListener('keydown',e=>{if(e.key==='Enter'||e.key===' '){e.preventDefault();showMethod(p.dataset.method,true);}});}
 }
 function csv() {
   const quote=v=>{let text=String(v??'');if(typeof v==='string'&&/^[=+@-]/.test(text))text="'"+text;return `"${text.replace(/"/g,'""')}"`;};
   const weights=parseWeights($('weights').value);
-  const columns=['position','method','comparison_profile','execution_host','scope','row_mode','selected_dataset','sort_metric','sort_direction','average_compression_rate','overall_compression_rate','compress_ns_per_point','decompress_ns_per_point','weight_a','weight_b','weight_c','normalized_compress','normalized_decompress','composite_score','average_rank','rank_dataset_coverage','normalization_reference_rows','compress_min','compress_max','decompress_min','decompress_max','normalization','rank_definition','dataset_coverage','datasets_in_scope','selected_configuration_by_dataset','source_profile_by_dataset','binary_sha256_by_dataset','eligible_column_set_sha256_by_dataset','measurement_status_by_dataset','timing_profile_status_by_dataset','timing_column_count','timing_aggregation'];
-  const body=currentRows.map((r,i)=>[i+1,r.method,r.runtime,runtimeHost(r.runtime),scopeKey(),state().mode,state().dataset,sort.key,sort.direction===1?'ascending':'descending',r.compression_rate,r.overall_rate,r.compression_time,r.decompression_time,...weights.map(w=>w.toFixed(1)),r.normalized_compression_time,r.normalized_decompression_time,r.composite_score,r.average_rank,r.rank_coverage,r.normalization_reference_rows,r.encode_min,r.encode_max,r.decode_min,r.decode_max,'min-max over all measured rows in selected comparison profile/scope/row-mode before search and visibility filters','mean per-dataset composite-score fractional rank; per-dataset min-max times',r.coverage,r.totalDatasets,JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.configuration]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.source_runtime]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.binary_sha256]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.eligible_column_set_sha256]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.measurement_status]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.timing_profile_status]))),r.timing_column_count,r.timing_aggregation].map(quote).join(','));
+  const columns=['position','method','comparison_profile','execution_host','scope','row_mode','selected_dataset','sort_metric','sort_direction','average_compression_rate','overall_compression_rate','compress_ns_per_point','decompress_ns_per_point','weight_a','weight_b','weight_c','normalized_compress','normalized_decompress','composite_score','average_rank','rank_dataset_coverage','normalization_reference_rows','compress_min','compress_max','decompress_min','decompress_max','normalization','rank_definition','dataset_coverage','datasets_in_scope','selected_configuration_by_dataset','source_profile_by_dataset','binary_sha256_by_dataset','eligible_column_set_sha256_by_dataset','measurement_status_by_dataset','timing_profile_status_by_dataset','timing_column_count','timing_aggregation','timed_subset_compress_ns_per_point','timed_subset_decompress_ns_per_point','timed_subset_dataset_coverage','timed_subset_dataset_denominator','timed_subset_status','timed_subset_source_profiles','timed_subset_source_hosts','selected_source_family_by_dataset','selected_source_comparison_profile_by_dataset','selected_source_host_by_dataset','strict_timing_reason','composite_reason'];
+  const body=currentRows.map((r,i)=>[i+1,r.method,r.runtime,runtimeHost(r.runtime),scopeKey(),state().mode,state().dataset,sort.key,sort.direction===1?'ascending':'descending',r.compression_rate,r.overall_rate,r.compression_time,r.decompression_time,...weights.map(w=>w.toFixed(1)),r.normalized_compression_time,r.normalized_decompression_time,r.composite_score,r.average_rank,r.rank_coverage,r.normalization_reference_rows,r.encode_min,r.encode_max,r.decode_min,r.decode_max,'min-max over all measured rows in selected language/scope/row-mode before search and visibility filters','mean per-dataset composite-score fractional rank; per-dataset min-max times',r.coverage,r.totalDatasets,JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.configuration]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.source_runtime]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.binary_sha256]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.eligible_column_set_sha256]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.measurement_status]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.timing_profile_status]))),r.timing_column_count,r.timing_aggregation,r.compression_time_timed_subset,r.decompression_time_timed_subset,r.timing_subset_coverage,r.timing_subset_denominator,r.timing_subset_status,JSON.stringify(r.timing_subset_source_profiles),JSON.stringify(r.timing_subset_hosts),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.source_family??s.family]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.source_comparison_profile??s.runtime]))),JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.source_execution_host??'source snapshot']))),metricAvailability(r,'compression_time').code,metricAvailability(r,'composite_score').code].map(quote).join(','));
   const url=URL.createObjectURL(new Blob(['\ufeff'+[columns.join(','),...body].join('\r\n')],{type:'text/csv;charset=utf-8'}));const a=document.createElement('a');a.href=url;a.download=`THULab-compression-${state().runtime}-${scopeKey()}-${state().dataset}.csv`;a.click();setTimeout(()=>URL.revokeObjectURL(url),1000);
 }
 function safeHttpUrl(value) {
@@ -326,11 +370,44 @@ function renderAbout() {
   const exclusions=c.exclusions||c.excluded_datasets||snapshot.exclusions||[];
   const catalogCount=number(datasetCatalog?.summary?.dataset_count??c.catalog_dataset_count)??datasetEntries().length,measuredCount=number(datasetCatalog?.summary?.published_result_dataset_count??datasetCatalog?.summary?.published_measurement_dataset_count??datasetCatalog?.summary?.measured_dataset_count??c.measured_dataset_count)??new Set(records.map(r=>r.dataset)).size;
   const terminal=c.native86_terminal_coverage||{};
-  const info={ 'Snapshot exported':snapshot.exported_at||s.exported_at||'Not reported','Dataset catalog':`${catalogCount} datasets; ${measuredCount} currently have published measurements and participate in rankings`,'Native86 server-166 terminal matrix':terminal.expected_pair_count?`${terminal.observed_pair_count} / ${terminal.expected_pair_count} dataset-method pairs; ${terminal.numeric_pair_count??0} contain published numeric aggregates, ${terminal.not_applicable_pair_count??0} are explicit N/A, ${terminal.problem_pair_count??0} ended with a failure status`:'See manifest and terminal coverage download','Dataset scope generated':s.generated_at||'Not reported', 'Source checkout':s.git_commit||'Not reported','Source files':`${s.source_files?.length??0} metadata inputs and ${s.result_csv_files_used?.length??0} result CSVs (hashes in manifest)`,'Result entries across scopes':`${records.length} (scope slices can reuse a measurement)`,'Worktree source state':s.worktree_dirty_inputs?.length?'Includes current local changes; input file hashes identify the published snapshot.':'See manifest for source file hashes.','Runtime environment':b.hardware||'Hardware details are not recorded in this exported result snapshot.','Lossless evidence':b.roundtrip_evidence||'Lossless-design method filter from the source project; per-run round-trip verification is not recorded here.'};
+  const info={ 'Snapshot exported':snapshot.exported_at||s.exported_at||'Unavailable in snapshot','Dataset catalog':`${catalogCount} datasets; ${measuredCount} currently have published measurements and participate in rankings`,'Native86 server-166 terminal matrix':terminal.expected_pair_count?`${terminal.observed_pair_count} / ${terminal.expected_pair_count} dataset-method pairs; ${terminal.numeric_pair_count??0} contain published numeric aggregates, ${terminal.not_applicable_pair_count??0} are explicit N/A, ${terminal.problem_pair_count??0} ended with a failure status`:'See manifest and terminal coverage download','Dataset scope generated':s.generated_at||'Unavailable in snapshot', 'Source checkout':s.git_commit||'Unavailable in snapshot','Source files':`${s.source_files?.length??0} metadata inputs and ${s.result_csv_files_used?.length??0} result CSVs (hashes in manifest)`,'Result entries across scopes':`${records.length} (scope slices can reuse a measurement)`,'Worktree source state':s.worktree_dirty_inputs?.length?'Includes current local changes; input file hashes identify the published snapshot.':'See manifest for source file hashes.','Runtime environment':b.hardware||'Hardware details are unavailable in this exported result snapshot.','Lossless evidence':b.roundtrip_evidence||'Lossless-design method filter from the source project; per-run round-trip verification is unavailable here.'};
   $('provenance').innerHTML=`<table class="provenance-table"><tbody>${Object.entries(info).map(([k,v])=>`<tr><th>${escape(k)}</th><td class="source-code">${escape(v)}</td></tr>`).join('')}</tbody></table>${exclusions.length?`<h3>Excluded or unavailable results</h3><p class="source-code">${escape(typeof exclusions==='string'?exclusions:JSON.stringify(exclusions))}</p>`:''}`;
 }
+function decodeCompactRecord(row,index) {
+  const t=snapshot.record_tables;
+  return {_compact_index:index,dataset:t.datasets[row[0]],scope:t.scopes[row[1]],runtime:t.runtimes[row[2]],comparison_profile:t.comparison_profiles[row[3]],family:t.families[row[4]],method:t.configurations[row[5]],algorithm_variant:t.configurations[row[5]],compression_rate:row[6],compression_time_ns_per_point:row[7],decompression_time_ns_per_point:row[8],original_size_bytes:row[9],compressed_size_bytes:row[10],timing_column_count:row[11],timing_aggregation:t.timing_aggregations[row[12]],eligible_column_set_sha256:t.support_sets[row[13]],measurement_status:t.measurement_statuses[row[14]],timing_profile_status:t.timing_statuses[row[15]],binary_sha256:t.binary_hashes[row[16]]};
+}
+function applyCppLatestView() {
+  if(!cppLatestView||cppLatestView.schema!=='compressionbenchmark-cpp-latest-view-v1'||cppLatestView.status!=='built_from_frozen_published_admitted_sources')throw new Error('The combined C++ selection sidecar has an invalid schema or status.');
+  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.');
+  const selectors=cppLatestView.selectors;if(!Array.isArray(selectors)||selectors.join('\0')!=='cpp\0java\0python')throw new Error('The combined view must expose exactly C++, Java, and Python.');
+  const selected=cppLatestView.cpp?.selected_rows;if(!Array.isArray(selected))throw new Error('The combined C++ selected-row index is missing.');
+  const seen=new Set(),cpp=[];
+  for(const item of selected){
+    const index=item?.raw_compact_index;
+    if(!Number.isInteger(index)||index<0||index>=compact.length||seen.has(index))throw new Error('The combined C++ selected-row indices are invalid or duplicated.');
+    seen.add(index);
+    const decoded=decodeCompactRecord(compact[index],index);
+    if(['java','python'].includes(decoded.comparison_profile)||decoded.comparison_profile!==item.source_comparison_profile||decoded.runtime!==item.source_runtime||decoded.family!==item.source_family)throw new Error(`Combined C++ provenance mismatch at compact row ${index}.`);
+    if(typeof item.canonical_family!=='string'||!item.canonical_family||typeof item.source_host!=='string'||!item.source_host)throw new Error(`Combined C++ identity metadata is incomplete at compact row ${index}.`);
+    const decodedTimingAdmitted=/^timing_admitted_/i.test(String(decoded.timing_profile_status??''));
+    if(Boolean(item.timing_admitted)!==decodedTimingAdmitted||item.pair_status!=='numeric')throw new Error(`Combined C++ admission metadata mismatch at compact row ${index}.`);
+    cpp.push({...decoded,comparison_profile:'cpp',family:item.canonical_family,source_family:item.source_family,source_comparison_profile:item.source_comparison_profile,source_runtime:item.source_runtime,source_execution_host:item.source_host,selection_authority:item.authority,pair_status:item.pair_status});
+  }
+  const ledger=cppLatestView.cpp?.pair_ledger;if(!Array.isArray(ledger))throw new Error('The combined C++ pair ledger is missing.');
+  for(const decision of ledger)if(decision.status!=='numeric'&&Array.isArray(decision.selected_raw_indices)&&decision.selected_raw_indices.length)throw new Error('A terminal N/A or unsupported decision attempts to fall back to an older numeric row.');
+  const expectedTiming=new Set(cppLatestView.cpp?.timing_subset?.selected_raw_indices||[]),actualTiming=new Set(selected.filter(item=>item.timing_admitted).map(item=>item.raw_compact_index));
+  if(expectedTiming.size!==actualTiming.size||[...expectedTiming].some(index=>!actualTiming.has(index)))throw new Error('The combined C++ admitted-timing index does not match selected-row metadata.');
+  const imported=compact.map(decodeCompactRecord).filter(row=>['java','python'].includes(row.comparison_profile)).map(row=>{
+    const publishedHost=snapshot.benchmark?.runtime_hosts?.[row.comparison_profile];
+    return {...row,source_family:row.family,source_comparison_profile:row.comparison_profile,source_runtime:row.runtime,source_execution_host:typeof publishedHost==='string'?publishedHost.trim():''};
+  });
+  snapshot.dataset_results=[...cpp,...imported];delete snapshot.compact_records;
+}
 function init() {
-  if(snapshot.compact_records){const t=snapshot.record_tables;snapshot.dataset_results=snapshot.compact_records.map(r=>({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]],method:t.configurations[r[5]],algorithm_variant:t.configurations[r[5]],compression_rate:r[6],compression_time_ns_per_point:r[7],decompression_time_ns_per_point:r[8],original_size_bytes:r[9],compressed_size_bytes:r[10],timing_column_count:r[11],timing_aggregation:t.timing_aggregations[r[12]],eligible_column_set_sha256:t.support_sets[r[13]],measurement_status:t.measurement_statuses[r[14]],timing_profile_status:t.timing_statuses[r[15]],binary_sha256:t.binary_hashes[r[16]]}));delete snapshot.compact_records;}
+  applyCppLatestView();
   for(const m of snapshot.methods||[]) { const method=typeof m==='string'?{name:m}:m;methods.set(method.name??method.method,method);for(const c of method.configurations||[])methods.set(c.algorithm_variant,{...method,name:c.algorithm_variant,family:method.name}); }
   for(const d of snapshot.datasets||[])datasets.set(d.key??d.dataset,d);
   records=(snapshot.dataset_results||snapshot.records||[]).map(normalizeRecord).filter(r=>r.method&&r.dataset&&r.compression_rate>0);
@@ -340,16 +417,21 @@ function init() {
   $('runtime').innerHTML=runtimes.map(r=>`<option value="${escape(r)}">${escape(runtimeName(r))}</option>`).join('');
   const requestedProfile=new URLSearchParams(location.search).get('profile');
   if(runtimes.includes(requestedProfile))$('runtime').value=requestedProfile;
+  else if(requestedProfile&&requestedProfile!=='cpp'){legacyProfileRequested=requestedProfile;$('runtime').value='cpp';}
+  else $('runtime').value=runtimes.includes(DEFAULT_PROFILE)?DEFAULT_PROFILE:runtimes[0];
   populateDatasetControls();
-  $('family').innerHTML='<option value="all">All method families</option>'+[...new Set(records.map(r=>r.family))].sort().map(f=>`<option value="${escape(f)}">${escape(f)}</option>`).join('');
-  $('method-count').textContent=countFmt(new Set(records.map(r=>r.family)).size);$('runtime-count').textContent=runtimes.length;$('record-count').textContent=countFmt(snapshot.coverage?.runtime_configuration_count??new Set(records.map(r=>`${r.runtime}\0${r.method}`)).size);
-  const exported=snapshot.exported_at||snapshot.source?.exported_at||'not reported';$('snapshot').textContent=`Result snapshot exported · ${String(exported).replace('T',' ').slice(0,19)}${exported==='not reported'?'':' UTC'}`;$('footer-snapshot').textContent=`Source inputs documented in the manifest`;
-  $('column-options').innerHTML=cols.map(c=>`<label><input type="checkbox" data-column="${c.key}" ${c.visible?'checked':''}>${escape(c.label)}</label>`).join('');
+  populateFamilyControl();
+  $('runtime-count').textContent=runtimes.length;$('record-count').textContent=countFmt(new Set(records.map(r=>`${r.runtime}\0${r.family}\0${r.method}`)).size);
+  const exported=snapshot.exported_at||snapshot.source?.exported_at||'unavailable';$('snapshot').textContent=`Result snapshot exported · ${String(exported).replace('T',' ').slice(0,19)}${exported==='unavailable'?'':' UTC'}`;$('footer-snapshot').textContent=`Source inputs documented in the manifest`;
+  $('column-options').innerHTML=cols.map(c=>`<label><input type="checkbox" data-column="${c.key}" ${defaultColumnVisible($('runtime').value,c)?'checked':''}>${escape(c.label)}</label>`).join('');
   $('weights').innerHTML=WEIGHT_TENTHS.map(w=>`<option value="${w.join(',')}" ${w.join(',')==='4,3,3'?'selected':''}>a = ${(w[0]/10).toFixed(1)} · b = ${(w[1]/10).toFixed(1)} · c = ${(w[2]/10).toFixed(1)}</option>`).join('');
   $('weights').addEventListener('change',refresh);
-  for(const input of $('column-options').querySelectorAll('input'))input.addEventListener('change',()=>{cols.find(c=>c.key===input.dataset.column).visible=input.checked;renderTable();});
-  for(const id of ['runtime','dtype','precision','family','row-mode','complete-only'])$(id).addEventListener('change',refresh);$('dataset').addEventListener('change',()=>{updateUrlState();refresh();if(activeTab==='dataset')renderDatasetCatalog();});$('search').addEventListener('input',refresh);$('chart-metric').addEventListener('change',renderChart);$('download').addEventListener('click',csv);
-  $('reset').addEventListener('click',()=>{$('runtime').value=runtimes.includes('cpp')?'cpp':runtimes[0];$('dtype').value='overall';$('precision').value='all';$('dataset').value='all';$('row-mode').value='family';$('search').value='';$('family').value='all';$('weights').value='4,3,3';$('complete-only').checked=false;selectedMethod=null;$('method-detail').hidden=true;sort={key:'compression_rate',direction:1};setTab(activeTab);});
+  for(const input of $('column-options').querySelectorAll('input'))input.addEventListener('change',()=>{const column=cols.find(c=>c.key===input.dataset.column);touchedColumns.add(column.key);column.visible=input.checked;renderTable();});
+  $('show-unavailable-columns').addEventListener('change',renderTable);
+  $('runtime').addEventListener('change',()=>{legacyProfileRequested='';populateFamilyControl();refresh();updateUrlState();});
+  for(const id of ['dtype','precision'])$(id).addEventListener('change',()=>{populateFamilyControl();refresh();});
+  for(const id of ['family','row-mode','complete-only'])$(id).addEventListener('change',refresh);$('dataset').addEventListener('change',()=>{updateUrlState();refresh();if(activeTab==='dataset')renderDatasetCatalog();});$('search').addEventListener('input',refresh);$('chart-metric').addEventListener('change',renderChart);$('download').addEventListener('click',csv);
+  $('reset').addEventListener('click',()=>{$('runtime').value=runtimes.includes(DEFAULT_PROFILE)?DEFAULT_PROFILE:runtimes[0];$('dtype').value='overall';$('precision').value='all';populateFamilyControl();$('dataset').value='all';$('row-mode').value='family';$('search').value='';$('family').value='all';$('weights').value='4,3,3';$('complete-only').checked=false;$('show-unavailable-columns').checked=false;touchedColumns.clear();for(const column of cols)column.visible=column.defaultVisible;legacyProfileRequested='';selectedMethod=null;$('method-detail').hidden=true;sort={key:'compression_rate',direction:1};setTab(activeTab);});
   for(const tab of document.querySelectorAll('[data-tab]'))tab.addEventListener('click',()=>setTab(tab.dataset.tab));
   $('method-doc-search').addEventListener('input',renderMethodDocumentation);$('operator-doc-search').addEventListener('input',renderOperatorDocumentation);$('dataset-catalog-search').addEventListener('input',renderDatasetCatalog);$('dataset-group-filter').addEventListener('change',renderDatasetCatalog);
   renderAbout();renderDocumentationViews();renderDatasetCatalog();setTab(location.hash.slice(1)||(requestedDataset&&$('dataset').value===requestedDataset?'dataset':'overall'));
@@ -357,6 +439,7 @@ function init() {
 }
 function updateUrlState() {
   const url=new URL(location.href);url.hash=activeTab;
+  const profile=$('runtime')?.value;if(profile)url.searchParams.set('profile',profile);
   const selected=$('dataset')?.value;
   if(selected&&selected!=='all')url.searchParams.set('dataset',selected);else url.searchParams.delete('dataset');
   history.replaceState(null,'',`${url.pathname}${url.search}${url.hash}`);
@@ -372,5 +455,14 @@ setupTheme();
 void loadReferenceCatalog();
 void loadOperatorEffect();
 void loadDatasetCatalog();
-try { const response=await fetch('./ui-data.json?v=20261013-corrected-five-v1',{cache:'no-cache'});if(!response.ok)throw new Error(`Snapshot request returned ${response.status}`);snapshot=await response.json();init(); }
+async function sha256Hex(buffer){const digest=await crypto.subtle.digest('SHA-256',buffer);return [...new Uint8Array(digest)].map(byte=>byte.toString(16).padStart(2,'0')).join('');}
+try {
+  const [snapshotResponse,sidecarResponse]=await Promise.all([fetch('./ui-data.json?v=20261013-cpp-latest-v1',{cache:'no-cache'}),fetch('./cpp-latest-view.json?v=20261013-cpp-latest-v1',{cache:'no-cache'})]);
+  if(!snapshotResponse.ok)throw new Error(`Snapshot request returned ${snapshotResponse.status}`);if(!sidecarResponse.ok)throw new Error(`Combined C++ sidecar request returned ${sidecarResponse.status}`);
+  const [snapshotBuffer,sidecarBuffer]=await Promise.all([snapshotResponse.arrayBuffer(),sidecarResponse.arrayBuffer()]);
+  const sidecarSha=await sha256Hex(sidecarBuffer);if(sidecarSha!==CPP_LATEST_VIEW_SHA256)throw new Error('The combined C++ sidecar does not match the independently reviewed release selection.');
+  const sidecarValue=JSON.parse(new TextDecoder().decode(sidecarBuffer));
+  const snapshotSha=await sha256Hex(snapshotBuffer);if(snapshotSha!==sidecarValue?.baseline?.ui_data_sha256)throw new Error('The combined C++ sidecar is not bound to this exact UI snapshot.');
+  snapshot=JSON.parse(new TextDecoder().decode(snapshotBuffer));cppLatestView=sidecarValue;init();
+}
 catch(e){$('load-error').hidden=false;$('load-error').textContent=`The result snapshot could not be loaded. Please reload the page or download the JSON from the repository. ${e.message}`;$('snapshot').textContent='Snapshot unavailable';$('leaderboard').querySelector('tbody').innerHTML='<tr><td class="empty-cell">Results unavailable.</td></tr>';}

availability.js

@@ -0,0 +1,169 @@
+export const DEFAULT_PROFILE = 'cpp';
+
+const PROFILE_LABELS = {
+  cpp: 'C++ · latest published result per dataset and method',
+  java: 'Java · imported published results',
+  python: 'Python · imported published results',
+};
+
+const FINITE = value => typeof value === 'number' && Number.isFinite(value);
+const METRIC_AVAILABLE = (row,key) => key==='rank_coverage'?FINITE(row?.[key])&&row[key]>0:FINITE(row?.[key]);
+const STRICT_COMPLETE_COLUMNS = new Set(['compression_time','decompression_time','normalized_compression_time','normalized_decompression_time','composite_score']);
+const sourceRows = row => Array.isArray(row?.source) ? row.source : [];
+const timingAdmitted = record => /^timing_admitted_/i.test(String(record?.timing_profile_status ?? ''));
+
+export function profileLabel(profile, fallback = profile) {
+  return PROFILE_LABELS[profile] || fallback;
+}
+
+export function isByteOnlyProfile(profile) {
+  return false;
+}
+
+export function defaultColumnVisible(profile, column) {
+  return Boolean(column.defaultVisible);
+}
+
+export function timingAvailability(row) {
+  const source = sourceRows(row),evidence=source.length?source:[row];
+  if (evidence.some(record => !timingAdmitted(record))) {
+    return {
+      code: 'timing_not_admitted',
+      short: 'Timing not admitted',
+      detail: 'Timing exists only as diagnostic or unqualified evidence for at least one selected dataset and is excluded from timing and composite rankings.',
+    };
+  }
+  if (!FINITE(row?.compression_time) || !FINITE(row?.decompression_time)) {
+    return {
+      code: 'incomplete_timing',
+      short: 'Incomplete timing',
+      detail: 'At least one selected dataset lacks a complete admitted compression/decompression timing pair.',
+    };
+  }
+  return {code: 'available', short: 'Available', detail: 'All selected timing inputs are admitted.'};
+}
+
+export function metricAvailability(row, key) {
+  if (FINITE(row?.[key])) return {code: 'available', short: '', detail: ''};
+  if (['compression_time_timed_subset', 'decompression_time_timed_subset'].includes(key)) {
+    const status=row?.timing_subset_status;
+    if(status==='no_admitted_timing')return {code:status,short:'No admitted timing',detail:'None of the current winning rate records has admitted timing.'};
+    if(status==='mixed_timing_contracts')return {code:status,short:'Mixed timing contracts',detail:'Admitted timing comes from different source profiles, hosts, or timing contracts and is not averaged.'};
+    if(status==='unbound_timing_source')return {code:status,short:'Timing source unbound',detail:'Source profile, host, and timing contract are not all bound, so subset timing is withheld.'};
+    if(status==='mixed_timing_aggregation')return {code:status,short:'Mixed timing basis',detail:'Column-level and dataset-level timing aggregation cannot be mixed.'};
+    return {code:'incomplete_timing',short:'Incomplete timing',detail:'A valid timed subset is unavailable.'};
+  }
+  if (['compression_time', 'decompression_time'].includes(key)) return timingAvailability(row);
+  if (['normalized_compression_time', 'normalized_decompression_time', 'composite_score'].includes(key)) {
+    const timing = timingAvailability(row);
+    if (timing.code !== 'available') return timing;
+    if (Number(row?.workload_signature_count) > 1) return {
+      code: 'support_mismatch',
+      short: 'Support mismatch',
+      detail: `Composite metrics are withheld because this view contains ${Number(row.workload_signature_count).toLocaleString('en-US')} distinct dataset/support signatures.`,
+    };
+    return {code: 'not_eligible', short: 'Not eligible', detail: 'No eligible normalization cohort is available for this row.'};
+  }
+  if (key === 'average_rank') {
+    const timing = timingAvailability(row);
+    if (timing.code !== 'available') return timing;
+    return {code: 'support_mismatch', short: 'Support mismatch', detail: 'No matched dataset/support cohort provides a rank for this row.'};
+  }
+  if (['overall_rate', 'compressed_bytes', 'original_bytes'].includes(key)) return {
+    code: 'incomplete_bytes', short: 'Incomplete bytes', detail: 'Complete compressed/original byte totals are unavailable for the selected records.',
+  };
+  return {code: 'unavailable', short: 'Unavailable', detail: 'This metric is unavailable for the selected records.'};
+}
+
+export function summarizeAvailability(rows, requestedColumns) {
+  const total = rows.length;
+  const counts = Object.fromEntries(requestedColumns.map(column => [column.key, rows.filter(row => METRIC_AVAILABLE(row,column.key)).length]));
+  const hidden = requestedColumns.filter(column => (counts[column.key] || 0) === 0);
+  const timingNotAdmitted = rows.filter(row => timingAvailability(row).code === 'timing_not_admitted').length;
+  const incompleteTiming = rows.filter(row => timingAvailability(row).code === 'incomplete_timing').length;
+  const supportMismatch = rows.filter(row =>
+    !FINITE(row?.composite_score) && timingAvailability(row).code === 'available' && Number(row?.workload_signature_count) > 1
+  ).length;
+  const noComparableCohort = rows.filter(row =>
+    !FINITE(row?.composite_score) && timingAvailability(row).code === 'available' && Number(row?.workload_signature_count) <= 1 && Number(row?.normalization_reference_rows) < 2
+  ).length;
+  const parts = [
+    `${counts.compression_rate || 0}/${total} rates`,
+    `${counts.compression_time || 0}/${total} admitted timings`,
+    `${counts.average_rank || 0}/${total} matched-support ranks`,
+    `${counts.composite_score || 0}/${total} composite scores`,
+  ];
+  const reasons = [];
+  if (timingNotAdmitted) reasons.push(`${timingNotAdmitted} timing not admitted`);
+  if (incompleteTiming) reasons.push(`${incompleteTiming} incomplete timing`);
+  if (supportMismatch) {
+    const signatures = Math.max(0, ...rows.map(row => Number(row?.workload_signature_count) || 0));
+    reasons.push(`${supportMismatch} composite scores withheld across ${signatures} dataset/support signatures`);
+  }
+  if(noComparableCohort)reasons.push(`${noComparableCohort} lack a comparable normalization cohort`);
+  return {total, counts, hidden, timingNotAdmitted, incompleteTiming, supportMismatch, noComparableCohort, parts, reasons};
+}
+
+export function visibleColumns(columns, rows, profile, showUnavailable, touched = new Set()) {
+  const requested = columns.filter(column => touched.has(column.key) ? column.visible : defaultColumnVisible(profile, column));
+  if (showUnavailable) return columns.filter(column => touched.has(column.key) ? column.visible : Boolean(column.defaultVisible));
+  return requested.filter(column => STRICT_COMPLETE_COLUMNS.has(column.key)?rows.length>0&&rows.every(row=>METRIC_AVAILABLE(row,column.key)):rows.some(row => METRIC_AVAILABLE(row,column.key)));
+}
+
+export function profileScopeText({profile, measuredDatasets, catalogDatasets}) {
+  const prefix = `${profileLabel(profile)} · ${measuredDatasets} measured datasets in this profile / ${catalogDatasets} catalog datasets.`;
+  if (profile === DEFAULT_PROFILE) return `${prefix} Duplicate C++ dataset/method pairs use the latest receipt-bound authority. Source profile and host remain visible in details and CSV. Strict timing and scores require complete same-contract coverage; partial admitted timing is labeled as a timed subset.`;
+  return `${prefix} These imported published results retain their original evidence boundaries; unqualified timing is not promoted into rankings.`;
+}
+
+export function timingSourceIdentity(record) {
+  const profile = record?.source_comparison_profile ?? record?.comparison_profile ?? record?.runtime ?? '';
+  const host = record?.source_execution_host ?? record?.execution_host ?? '';
+  const contract = record?.timing_contract ?? record?.timing_profile_status ?? '';
+  return `${profile}\u0000${host}\u0000${contract}`;
+}
+
+export function aggregateTimedSubset(source) {
+  const denominator = new Set(sourceRows({source}).map(record => record.dataset)).size;
+  const admitted = sourceRows({source}).filter(record =>
+    timingAdmitted(record) && FINITE(record?.compression_time) && FINITE(record?.decompression_time) &&
+    Number(record.compression_time) >= 0 && Number(record.decompression_time) >= 0
+  );
+  const boundIdentity = record => {
+    const profile=record?.source_comparison_profile ?? record?.comparison_profile ?? record?.runtime ?? '';
+    const host=record?.source_execution_host ?? record?.execution_host ?? '';
+    const contract=record?.timing_contract ?? record?.timing_profile_status ?? '';
+    return profile && host && contract;
+  };
+  const identities = [...new Set(admitted.map(timingSourceIdentity))];
+  const base = {
+    timing_subset_coverage: new Set(admitted.map(record => record.dataset)).size,
+    timing_subset_denominator: denominator,
+    timing_subset_source_identity: identities.length === 1 ? identities[0] : '',
+    timing_subset_source_profiles: [...new Set(admitted.map(record => record.source_comparison_profile ?? record.comparison_profile ?? record.runtime ?? ''))].filter(Boolean),
+    timing_subset_hosts: [...new Set(admitted.map(record => record.source_execution_host ?? record.execution_host ?? ''))].filter(Boolean),
+  };
+  if (!admitted.length) return {...base, compression_time_timed_subset:null, decompression_time_timed_subset:null, timing_subset_status:'no_admitted_timing'};
+  if (!admitted.every(boundIdentity)) return {...base, compression_time_timed_subset:null, decompression_time_timed_subset:null, timing_subset_status:'unbound_timing_source'};
+  if (identities.length !== 1) return {...base, compression_time_timed_subset:null, decompression_time_timed_subset:null, timing_subset_status:'mixed_timing_contracts'};
+  const completeColumnTiming = admitted.every(record => record.timing_aggregation === 'column_mean' && Number.isInteger(record.timing_column_count) && record.timing_column_count > 0);
+  const completeDatasetTiming = admitted.every(record => record.timing_aggregation === 'dataset_aggregate' && record.timing_column_count === 0);
+  if (!completeColumnTiming && !completeDatasetTiming) return {...base, compression_time_timed_subset:null, decompression_time_timed_subset:null, timing_subset_status:'mixed_timing_aggregation'};
+  const aggregate = key => completeColumnTiming
+    ? admitted.reduce((sum,record) => sum + Number(record[key]) * record.timing_column_count, 0) / admitted.reduce((sum,record) => sum + record.timing_column_count, 0)
+    : admitted.reduce((sum,record) => sum + Number(record[key]), 0) / admitted.length;
+  return {
+    ...base,
+    compression_time_timed_subset:aggregate('compression_time'),
+    decompression_time_timed_subset:aggregate('decompression_time'),
+    timing_subset_status:completeColumnTiming?'column_mean':'dataset_mean',
+  };
+}
+
+export function strictTimingMode(source) {
+  const rows=sourceRows({source});
+  if(!rows.length||rows.some(record=>!timingAdmitted(record)||!FINITE(record?.compression_time)||!FINITE(record?.decompression_time)))return 'unavailable';
+  const subset=aggregateTimedSubset(rows),datasetCount=new Set(rows.map(record=>record.dataset)).size;
+  if(subset.timing_subset_coverage!==datasetCount)return 'unavailable';
+  return ['column_mean','dataset_mean'].includes(subset.timing_subset_status)?subset.timing_subset_status:'unavailable';
+}

build_cpp_latest_view.py

@@ -0,0 +1,621 @@
+#!/usr/bin/env python3
+"""Build an index-only, receipt-bound merged C++ view for the frozen site payload.
+
+The output contains no copied or transformed measurements.  Every selected row
+is an integer index into the exact frozen ``ui-data.json`` compact record array.
+Pair-level campaign selection is atomic: missing scopes in the selected campaign
+are tombstoned and can never be filled from an older campaign.
+"""
+
+from __future__ import annotations
+
+import gzip
+import hashlib
+import json
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any
+
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[2]
+CANDIDATE = HERE.parent / "candidate"
+OUTPUT = CANDIDATE / "cpp-latest-view.json"
+
+EXPECTED_UI_SHA256 = "ef5aa05289f609f2f62ceed009ee17247c8b4767bba8f4aa8cd522ce83d3521d"
+EXPECTED_DATA_SHA256 = "b7b542c5731786d0486e89de889f024c7e6f69eacb68a7df67bc00179b07af4c"
+EXPECTED_BASELINE_VERIFIED_SHA256 = "9b5ea536ddf8e60db9dcc54d7d0b98420fba222a38b499b50aa193cdc3fd25a9"
+BASELINE_REVISION = "d84ab7155ac1d2279610facdebe8aae1681b655b"
+PUBLISHED_INPUTS = {
+    "ui-data.json",
+    "data.json",
+    "native86-terminal-matrix.jsonl.gz",
+    "native86-row-support-v4-portable-results.jsonl.gz",
+    "corrected-five425-portable-results.jsonl.gz",
+    "NATIVE86_FULL_MATRIX_INTEGRATION_V6.json",
+    "NATIVE86_ACCEPTED_COMPLETION_V7.json",
+    "CORRECTED_FIVE425_INDEPENDENT_ACCEPTANCE.json",
+    "CORRECTED_FIVE425_PORTABLE_MANIFEST.json",
+    "native86-recovery-reconciliation.json",
+}
+EXPECTED_RECEIPTS = {
+    "NATIVE86_FULL_MATRIX_INTEGRATION_V6.json": ("site-native86-full-matrix-integration-v2", "passed"),
+    "NATIVE86_ACCEPTED_COMPLETION_V7.json": ("compressionbenchmark-native86-accepted-completion-integration-v1", "passed_not_published"),
+    "CORRECTED_FIVE425_INDEPENDENT_ACCEPTANCE.json": ("compressionbenchmark-corrected-five425-independent-acceptance-v2", "accepted"),
+    "CORRECTED_FIVE425_PORTABLE_MANIFEST.json": ("compressionbenchmark-corrected-five425-portable-manifest-v1", "accepted_portable_export"),
+    "native86-recovery-reconciliation.json": ("paper164-recovery-key-reconciliation-v1", "passed_all_original_problem_identities_have_accepted_rate_byte_replacements"),
+}
+
+MAIN = "cpp-native166-main-458a218f"
+V9 = "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3"
+COMPLETION_REUSE = "cpp-native166-current-recovery-v3-baseline86-fixed-profiles-20260919-v3"
+COMPLETION_RERUN = "cpp-native166-row-support-v4-baseline86-fixed-profiles-20260919-v3"
+CORRECTED = "cpp-native166-corrected-five-20261012-v1"
+HOST192 = {
+    "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3",
+    "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2",
+    "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-fixed-20261010-v1",
+    "cpp-native192-next5-baseline86-fixed-profiles-20260919-v3",
+}
+RECOVERY_PROFILES = {V9, *HOST192}
+CORRECTED_DATASETS = {
+    "github_top_projects",
+    "magseven_ml_ready_high_frequency_anomaly",
+    "traqq_weekly_activity",
+    "trending_stocks_yahoo_finance",
+    "us_stock_financial_ratios",
+}
+
+# These are directional legacy-label -> active Native85-label overrides.  They
+# are backed by the explicit alias and family-membership registries, not fuzzy
+# matching.
+SAFE_ALIASES = {
+    "TS_2DIFF": "2DIFF",
+    "CHIMP": "Chimp",
+    "Dictionary": "Dict.",
+    "FPCompress DPratio": "FPCmp-R",
+    "FPCompress DPspeed": "FPCmp-S",
+    "GORILLA": "Gorilla",
+    "GZIP": "gzip",
+    "LZO1X": "LZO1",
+    "SNAPPY": "Snappy",
+    "Slz_deflate": "SLZ",
+    "Slz_gzip": "SLZ",
+    "Slz_zlib": "SLZ",
+    "SPRINTZ": "Sprintz",
+    "Stream VByte": "SVB",
+    "UCL NRV": "NRV",
+    "UCL NRV2b": "NRV",
+    "ZSTD": "Zstd",
+}
+AMBIGUOUS_NOT_ALIASED: dict[str, str] = {}
+
+
+def sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def load_json(path: Path) -> Any:
+    return json.loads(path.read_text())
+
+
+def load_jsonl_gz(path: Path) -> list[dict[str, Any]]:
+    with gzip.open(path, "rt") as stream:
+        return [json.loads(line) for line in stream if line.strip()]
+
+
+def compact_rows(ui: dict[str, Any]) -> list[dict[str, Any]]:
+    tables = ui["record_tables"]
+    rows = []
+    for index, row in enumerate(ui["compact_records"]):
+        rows.append(
+            {
+                "raw_compact_index": index,
+                "dataset": tables["datasets"][row[0]],
+                "scope": tables["scopes"][row[1]],
+                "source_runtime": tables["runtimes"][row[2]],
+                "source_comparison_profile": tables["comparison_profiles"][row[3]],
+                "source_family": tables["families"][row[4]],
+                "algorithm_variant": tables["configurations"][row[5]],
+                "eligible_support_sha256": tables["support_sets"][row[13]],
+                "measurement_status": tables["measurement_statuses"][row[14]],
+                "timing_profile_status": tables["timing_statuses"][row[15]],
+            }
+        )
+    return rows
+
+
+def receipt_entry(path: Path) -> dict[str, Any]:
+    value = load_json(path)
+    return {
+        "path": path.name,
+        "sha256": sha256(path),
+        "schema": value.get("schema"),
+        "status": value.get("status"),
+        "created_at": value.get("created_at"),
+    }
+
+
+def main() -> None:
+    ui_path = CANDIDATE / "ui-data.json"
+    data_path = CANDIDATE / "data.json"
+    if sha256(ui_path) != EXPECTED_UI_SHA256:
+        raise RuntimeError("frozen ui-data.json SHA mismatch")
+    if sha256(data_path) != EXPECTED_DATA_SHA256:
+        raise RuntimeError("frozen data.json SHA mismatch")
+
+    baseline_verified_path = HERE.parent / "BASELINE_VERIFIED.json"
+    if sha256(baseline_verified_path) != EXPECTED_BASELINE_VERIFIED_SHA256:
+        raise RuntimeError("published baseline verification receipt SHA mismatch")
+    baseline_verified = load_json(baseline_verified_path)
+    verified_files = {item["path"]: item["sha256"] for item in baseline_verified["files"]}
+    if (
+        baseline_verified.get("status") != "verified"
+        or baseline_verified.get("revision") != BASELINE_REVISION
+        or verified_files.get("ui-data.json") != EXPECTED_UI_SHA256
+        or verified_files.get("data.json") != EXPECTED_DATA_SHA256
+    ):
+        raise RuntimeError("published baseline verification receipt does not bind the frozen payload")
+    for name in sorted(PUBLISHED_INPUTS):
+        path = CANDIDATE / name
+        if not path.is_file() or name not in verified_files or sha256(path) != verified_files[name]:
+            raise RuntimeError(f"published input is absent or differs from BASELINE_VERIFIED: {name}")
+    for name, (expected_schema, expected_status) in EXPECTED_RECEIPTS.items():
+        value = load_json(CANDIDATE / name)
+        if value.get("schema") != expected_schema or value.get("status") != expected_status:
+            raise RuntimeError(f"published receipt schema/status mismatch: {name}")
+
+    ui = load_json(ui_path)
+    data = load_json(data_path)
+    rows = compact_rows(ui)
+    all_scopes = tuple(ui["record_tables"]["scopes"])
+    hosts = data["benchmark"]["runtime_hosts"]
+
+    by_profile_pair: dict[tuple[str, str, str], list[dict[str, Any]]] = defaultdict(list)
+    legacy_families: set[str] = set()
+    for row in rows:
+        by_profile_pair[(row["source_comparison_profile"], row["dataset"], row["source_family"])].append(row)
+        if row["source_comparison_profile"] == "cpp":
+            legacy_families.add(row["source_family"])
+
+    terminal = load_jsonl_gz(CANDIDATE / "native86-terminal-matrix.jsonl.gz")
+    if any(row.get("record_type") != "terminal_pair" for row in terminal):
+        raise RuntimeError("Native85 terminal matrix contains a non-terminal-pair record")
+    active85 = sorted({row["method_label"] for row in terminal})
+    datasets164 = sorted({row["dataset_id"] for row in terminal})
+    if len(active85) != 85 or len(datasets164) != 164 or len(terminal) != 13_940:
+        raise RuntimeError("Native85 terminal matrix cardinality mismatch")
+    terminal_pairs = {(row["dataset_id"], row["method_label"]): row for row in terminal}
+    if len(terminal_pairs) != 13_940:
+        raise RuntimeError("Native85 terminal matrix pair duplication")
+
+    # authority[pair] always describes exactly one winning campaign, or an
+    # explicit terminal tombstone.  It is never a best-value selection.
+    authority: dict[tuple[str, str], dict[str, Any]] = {}
+    for pair, row in terminal_pairs.items():
+        if row["terminal_status"] == "final_numeric_available":
+            authority[pair] = {
+                "status": "numeric",
+                "profile": MAIN,
+                "authority": "native85_main_terminal_matrix",
+                "reason": "Native85 terminal matrix reports accepted numeric support in the main campaign.",
+                "recency_rank": 10,
+            }
+        elif row["terminal_status"] == "not_applicable_no_eligible_columns":
+            authority[pair] = {
+                "status": "not_applicable",
+                "profile": MAIN,
+                "authority": "native85_main_terminal_matrix",
+                "reason": "Native85 terminal matrix is final all-N/A; legacy numeric rows are blocked.",
+                "recency_rank": 10,
+            }
+        else:
+            authority[pair] = {
+                "status": "unresolved_original_problem",
+                "profile": None,
+                "authority": "native85_main_terminal_matrix",
+                "reason": "Original Native85 problem; an accepted recovery overlay is required.",
+                "recency_rank": 10,
+            }
+
+    # Independently accepted V9 plus server-192 recovery: 174 unique pairs.
+    recovery_candidates: dict[tuple[str, str], set[str]] = defaultdict(set)
+    for profile in RECOVERY_PROFILES:
+        for candidate_profile, dataset, family in by_profile_pair:
+            if candidate_profile == profile:
+                recovery_candidates[(dataset, family)].add(profile)
+    if len(recovery_candidates) != 174:
+        raise RuntimeError(f"expected 174 unique accepted V9/192 recovery pairs, found {len(recovery_candidates)}")
+    for pair, profiles in recovery_candidates.items():
+        if pair not in terminal_pairs:
+            raise RuntimeError(f"recovery pair outside Native85 matrix: {pair}")
+        if len(profiles) == 1:
+            profile = next(iter(profiles))
+            overlap_rule = None
+        elif pair == ("weather_data_bavaria", "LZG") and profiles == {
+            V9,
+            "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2",
+        }:
+            profile = "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2"
+            overlap_rule = "explicit current LZG parameter contract level=5, fast=false; not ratio-based"
+        else:
+            raise RuntimeError(f"unadjudicated recovery overlap for {pair}: {sorted(profiles)}")
+        authority[pair] = {
+            "status": "numeric",
+            "profile": profile,
+            "authority": "native85_v9_or_192_independently_accepted_recovery",
+            "reason": overlap_rule or "Unique independently accepted recovery source for this pair.",
+            "recency_rank": 20,
+            "candidate_profiles": sorted(profiles),
+        }
+
+    # Accepted completion repairs exactly the other 328 original problem pairs.
+    completion = load_jsonl_gz(CANDIDATE / "native86-row-support-v4-portable-results.jsonl.gz")
+    if len(completion) != 328:
+        raise RuntimeError("accepted completion must contain exactly 328 pairs")
+    if any(row.get("schema") != "compressionbenchmark-native328-portable-pair-v1" for row in completion):
+        raise RuntimeError("accepted completion row schema mismatch")
+    completion_profiles = {
+        "reuse_v3_recovered": COMPLETION_REUSE,
+        "rerun_v4": COMPLETION_RERUN,
+    }
+    for item in completion:
+        pair = (item["dataset_id"], item["method"])
+        if pair in recovery_candidates:
+            raise RuntimeError(f"completion overlaps prior accepted recovery: {pair}")
+        profile = completion_profiles[item["action"]]
+        authority[pair] = {
+            "status": "numeric",
+            "profile": profile,
+            "authority": "native328_independently_accepted_completion",
+            "reason": f"Accepted Native328 completion action={item['action']}.",
+            "recency_rank": 30,
+            "pair_receipt_sha256": item["receipt_sha256"],
+        }
+
+    unresolved = [pair for pair, decision in authority.items() if decision["status"] == "unresolved_original_problem"]
+    if unresolved:
+        raise RuntimeError(f"unresolved Native85 problem pairs remain: {unresolved[:3]}")
+
+    # Latest corrected-input campaign atomically supersedes every older version
+    # for all five datasets and all 85 active methods, including unsupported and
+    # mixed pairs with no overall row.
+    corrected = load_jsonl_gz(CANDIDATE / "corrected-five425-portable-results.jsonl.gz")
+    if any(row.get("schema") != "compressionbenchmark-corrected-five425-portable-pair-v1" for row in corrected):
+        raise RuntimeError("corrected-five portable row schema mismatch")
+    corrected_pairs = {(row["dataset_id"], row["method"]): row for row in corrected}
+    expected_corrected = {(dataset, family) for dataset in CORRECTED_DATASETS for family in active85}
+    if set(corrected_pairs) != expected_corrected or len(corrected) != 425:
+        raise RuntimeError("corrected-five pair coverage is not exactly 5 x 85")
+    for pair, item in corrected_pairs.items():
+        if item["numeric_result"]:
+            status = "numeric"
+            reason = "Latest independently accepted corrected-input pair; all older scopes/configurations are superseded."
+            profile: str | None = CORRECTED
+        else:
+            status = "unsupported"
+            reason = "Latest corrected-input pair is all-unsupported; all prior numeric/configuration rows are tombstoned."
+            profile = CORRECTED
+        authority[pair] = {
+            "status": status,
+            "profile": profile,
+            "authority": "corrected_five425_independent_acceptance",
+            "reason": reason,
+            "recency_rank": 40,
+            "pair_terminal_class": item["pair_terminal_class"],
+            "pair_receipt_sha256": item["receipt_sha256"],
+        }
+
+    selected_rows: list[dict[str, Any]] = []
+    pair_ledger: list[dict[str, Any]] = []
+    selected_indices: set[int] = set()
+    pair_status_counts: Counter[str] = Counter()
+
+    for dataset, family in sorted(authority):
+        decision = authority[(dataset, family)]
+        profile = decision["profile"]
+        chosen = [] if profile is None else list(by_profile_pair.get((profile, dataset, family), []))
+        if decision["status"] == "numeric" and not chosen:
+            raise RuntimeError(f"numeric authority has no compact rows: {(dataset, family, profile)}")
+        if decision["status"] != "numeric" and chosen:
+            raise RuntimeError(f"terminal tombstone unexpectedly has rows: {(dataset, family, profile)}")
+
+        # Do not allow duplicate scientific row identity within a winning
+        # campaign.  Multiple configurations remain distinct by contract.
+        identities = [
+            (
+                row["scope"],
+                row["algorithm_variant"],
+                row["eligible_support_sha256"],
+                row["source_runtime"],
+            )
+            for row in chosen
+        ]
+        if len(identities) != len(set(identities)):
+            raise RuntimeError(f"duplicate row identity in winning campaign: {(dataset, family, profile)}")
+
+        source_host = None if profile is None else hosts[profile]
+        pair_indices = sorted(row["raw_compact_index"] for row in chosen)
+        scopes = sorted({row["scope"] for row in chosen})
+        for row in chosen:
+            index = row["raw_compact_index"]
+            if index in selected_indices:
+                raise RuntimeError(f"compact row selected twice: {index}")
+            selected_indices.add(index)
+            timing_admitted = row["timing_profile_status"].startswith("timing_admitted_")
+            selected_rows.append(
+                {
+                    "raw_compact_index": index,
+                    "canonical_family": family,
+                    "source_family": row["source_family"],
+                    "source_comparison_profile": profile,
+                    "source_runtime": row["source_runtime"],
+                    "source_host": source_host,
+                    "authority": decision["authority"],
+                    "pair_status": decision["status"],
+                    "timing_admitted": timing_admitted,
+                    "measurement_status": row["measurement_status"],
+                    "timing_profile_status": row["timing_profile_status"],
+                }
+            )
+        pair_status_counts[decision["status"]] += 1
+        pair_ledger.append(
+            {
+                "dataset": dataset,
+                "canonical_family": family,
+                "decision": "select_winning_campaign" if chosen else "terminal_tombstone",
+                "status": decision["status"],
+                "source_comparison_profile": profile,
+                "source_host": source_host,
+                "selected_raw_indices": pair_indices,
+                "selected_scopes": scopes,
+                "missing_scopes_tombstoned": sorted(set(all_scopes) - set(scopes)),
+                "recency_rank": decision["recency_rank"],
+                "authority": decision["authority"],
+                "reason": decision["reason"],
+                **({"pair_terminal_class": decision["pair_terminal_class"]} if "pair_terminal_class" in decision else {}),
+                **({"pair_receipt_sha256": decision["pair_receipt_sha256"]} if "pair_receipt_sha256" in decision else {}),
+                **({"candidate_profiles": decision["candidate_profiles"]} if "candidate_profiles" in decision else {}),
+            }
+        )
+
+    # Preserve concrete legacy-only algorithm families and every configuration
+    # within their legacy campaign.  Safe aliases into Native85 are excluded,
+    # because their Native85 terminal/tombstone decision is authoritative.
+    mapped_legacy = {SAFE_ALIASES.get(family, family) for family in legacy_families}
+    legacy_extras = sorted(family for family in legacy_families if SAFE_ALIASES.get(family, family) not in active85)
+    expected_extras = sorted(["BSS+LZ4", "Sub-column"])
+    if legacy_extras != expected_extras:
+        raise RuntimeError(f"unexpected legacy extra families: {legacy_extras}")
+    if not set(active85).issubset(mapped_legacy):
+        missing = sorted(set(active85) - mapped_legacy)
+        raise RuntimeError(f"active Native85 labels absent after explicit legacy aliases: {missing}")
+
+    for family in legacy_extras:
+        family_rows = [row for row in rows if row["source_comparison_profile"] == "cpp" and row["source_family"] == family]
+        for row in family_rows:
+            index = row["raw_compact_index"]
+            if index in selected_indices:
+                raise RuntimeError(f"legacy compact row selected twice: {index}")
+            selected_indices.add(index)
+            selected_rows.append(
+                {
+                    "raw_compact_index": index,
+                    "canonical_family": family,
+                    "source_family": family,
+                    "source_comparison_profile": "cpp",
+                    "source_runtime": row["source_runtime"],
+                    "source_host": hosts["cpp"],
+                    "authority": "legacy_extra_family_preserved_all_configurations",
+                    "pair_status": "numeric",
+                    "timing_admitted": row["timing_profile_status"].startswith("timing_admitted_"),
+                    "measurement_status": row["measurement_status"],
+                    "timing_profile_status": row["timing_profile_status"],
+                }
+            )
+        for dataset in sorted({row["dataset"] for row in family_rows}):
+            chosen = [row for row in family_rows if row["dataset"] == dataset]
+            pair_ledger.append(
+                {
+                    "dataset": dataset,
+                    "canonical_family": family,
+                    "decision": "preserve_legacy_extra_family_all_configurations",
+                    "status": "numeric",
+                    "source_comparison_profile": "cpp",
+                    "source_host": hosts["cpp"],
+                    "selected_raw_indices": sorted(row["raw_compact_index"] for row in chosen),
+                    "selected_scopes": sorted({row["scope"] for row in chosen}),
+                    "missing_scopes_tombstoned": [],
+                    "recency_rank": 0,
+                    "authority": "legacy_extra_family_preserved_all_configurations",
+                    "reason": "Concrete legacy-only family has no evidenced Native85 equivalent; all legacy configurations are preserved.",
+                }
+            )
+
+    selected_rows.sort(key=lambda item: item["raw_compact_index"])
+    pair_ledger.sort(key=lambda item: (item["dataset"], item["canonical_family"]))
+    timing_indices = [row["raw_compact_index"] for row in selected_rows if row["timing_admitted"]]
+    selected_index_to_source = {row["raw_compact_index"]: row for row in rows}
+    scope_numeric_dataset_counts = {
+        scope: len(
+            {
+                selected_index_to_source[row["raw_compact_index"]]["dataset"]
+                for row in selected_rows
+                if selected_index_to_source[row["raw_compact_index"]]["scope"] == scope
+            }
+        )
+        for scope in all_scopes
+    }
+    scope_numeric_pair_counts = {
+        scope: len(
+            {
+                (
+                    selected_index_to_source[row["raw_compact_index"]]["dataset"],
+                    row["canonical_family"],
+                )
+                for row in selected_rows
+                if selected_index_to_source[row["raw_compact_index"]]["scope"] == scope
+            }
+        )
+        for scope in all_scopes
+    }
+
+    receipts = {
+        name: receipt_entry(CANDIDATE / name)
+        for name in [
+            "NATIVE86_FULL_MATRIX_INTEGRATION_V6.json",
+            "NATIVE86_ACCEPTED_COMPLETION_V7.json",
+            "CORRECTED_FIVE425_INDEPENDENT_ACCEPTANCE.json",
+            "CORRECTED_FIVE425_PORTABLE_MANIFEST.json",
+            "native86-recovery-reconciliation.json",
+        ]
+    }
+    receipts.update(
+        {
+            "native86-terminal-matrix.jsonl.gz": {
+                "path": "native86-terminal-matrix.jsonl.gz",
+                "sha256": sha256(CANDIDATE / "native86-terminal-matrix.jsonl.gz"),
+            },
+            "native86-row-support-v4-portable-results.jsonl.gz": {
+                "path": "native86-row-support-v4-portable-results.jsonl.gz",
+                "sha256": sha256(CANDIDATE / "native86-row-support-v4-portable-results.jsonl.gz"),
+            },
+            "corrected-five425-portable-results.jsonl.gz": {
+                "path": "corrected-five425-portable-results.jsonl.gz",
+                "sha256": sha256(CANDIDATE / "corrected-five425-portable-results.jsonl.gz"),
+            },
+        }
+    )
+
+    alias_source = ROOT / "scripts" / "operator86_required_paths_v1.py"
+    alias_evidence_paths = [
+        alias_source,
+        ROOT / "cpp" / "native_baseline86_v1" / "UPSTREAM_SPECIALISTS_SOURCE_AUDIT.md",
+        ROOT / "cpp" / "native_baseline86_v1" / "upstream_specialists.cpp",
+        ROOT / "cpp" / "src" / "remaining_codec_action_catalog.cpp",
+        ROOT / "backend" / "myapp" / "method_catalog.py",
+    ]
+    sidecar = {
+        "schema": "compressionbenchmark-cpp-latest-view-v1",
+        "status": "built_from_frozen_published_admitted_sources",
+        "baseline": {
+            "revision": BASELINE_REVISION,
+            "ui_data_path": "ui-data.json",
+            "ui_data_sha256": EXPECTED_UI_SHA256,
+            "data_path": "data.json",
+            "data_sha256": EXPECTED_DATA_SHA256,
+            "compact_record_count": len(rows),
+            "verification_receipt": {
+                "path": "../BASELINE_VERIFIED.json",
+                "sha256": sha256(baseline_verified_path),
+                "observed_at": baseline_verified.get("observed_at"),
+            },
+        },
+        "identity_contract": {
+            "winning_campaign_identity": ["dataset", "canonical_family"],
+            "selected_row_identity": [
+                "raw_compact_index",
+                "scope",
+                "algorithm_variant",
+                "eligible_support_sha256",
+                "source_runtime",
+            ],
+            "atomicity": "One accepted campaign wins per dataset and canonical family. All its compact rows are selected; absent scopes are tombstoned and never backfilled.",
+            "numeric_policy": "The sidecar stores indices and provenance only. Numeric values are read unchanged from the SHA-bound compact record.",
+            "normalized_runtime": "cpp",
+            "source_profile_retention": "source_comparison_profile/source_runtime/source_host remain visible provenance metadata",
+        },
+        "alias_contract": {
+            "direction": "legacy_source_family_to_native85_canonical_family",
+            "overrides": SAFE_ALIASES,
+            "source": {
+                "path": "scripts/operator86_required_paths_v1.py",
+                "sha256": sha256(alias_source),
+                "evidence": "PIPELINE_ALIASES, documented punctuation-insensitive resolution, and method_catalog family-membership lists; direction is inverted only for evidenced legacy spellings.",
+            },
+            "evidence_files": [
+                {"path": str(path.relative_to(ROOT)), "sha256": sha256(path)}
+                for path in alias_evidence_paths
+            ],
+            "ambiguous_not_aliased": AMBIGUOUS_NOT_ALIASED,
+            "legacy_extra_families": legacy_extras,
+        },
+        "precedence": [
+            {"rank": 0, "authority": "legacy_extra_family_preserved_all_configurations", "scope": "families without an evidenced Native85 equivalent"},
+            {"rank": 10, "authority": "native85_main_terminal_matrix", "scope": "164 x 85 base terminal matrix; N/A blocks legacy fallback"},
+            {"rank": 20, "authority": "native85_v9_or_192_independently_accepted_recovery", "scope": "174 accepted original-problem repairs"},
+            {"rank": 30, "authority": "native328_independently_accepted_completion", "scope": "remaining 328 accepted original-problem repairs"},
+            {"rank": 40, "authority": "corrected_five425_independent_acceptance", "scope": "latest corrected inputs for five datasets x 85 methods; supersedes every older scope/configuration"},
+        ],
+        "receipts": receipts,
+        "selectors": ["cpp", "java", "python"],
+        "cpp": {
+            "merged_runtime": "cpp",
+            "selected_rows": selected_rows,
+            "pair_ledger": pair_ledger,
+            "active_native85_families": active85,
+            "legacy_extra_families": legacy_extras,
+            "counts": {
+                "active_native85_pair_conclusions": len(authority),
+                "active_native85_pair_status": dict(sorted(pair_status_counts.items())),
+                "active_native85_numeric_pairs": pair_status_counts["numeric"],
+                "active_native85_terminal_tombstone_pairs": pair_status_counts["not_applicable"] + pair_status_counts["unsupported"],
+                "legacy_extra_pair_count": sum(1 for row in pair_ledger if row["authority"] == "legacy_extra_family_preserved_all_configurations"),
+                "selected_compact_row_count": len(selected_rows),
+                "timing_admitted_selected_row_count": len(timing_indices),
+                "scope_numeric_dataset_counts": scope_numeric_dataset_counts,
+                "scope_numeric_pair_counts": scope_numeric_pair_counts,
+            },
+            "timing_subset": {
+                "contract": "Only exact rows already marked timing_admitted_* in the frozen payload enter timing rankings. No timing is borrowed across campaigns, hosts, configurations, or tombstones.",
+                "selected_raw_indices": timing_indices,
+                "selected_row_count": len(timing_indices),
+                "source_profile_counts": dict(
+                    sorted(
+                        Counter(
+                            row["source_comparison_profile"]
+                            for row in selected_rows
+                            if row["timing_admitted"]
+                        ).items()
+                    )
+                ),
+            },
+        },
+        "warnings": [
+            "N/A and unsupported are terminal support conclusions, not zero-valued measurements.",
+            "A corrected mixed-support pair may intentionally lack overall scope; the missing overall result is tombstoned rather than taken from an older input version.",
+            "FreshRetailNet-50K corrected 114-column rerun is pending and is not represented as a newer accepted campaign in this sidecar.",
+            "Only BSS+LZ4 and Sub-column remain legacy extras; all other legacy spellings are explicitly mapped by the bound registries.",
+            "The server-192 LZG overlap is resolved by the explicit current level=5, fast=false parameter contract, never by compression ratio.",
+        ],
+    }
+
+    OUTPUT.write_text(json.dumps(sidecar, ensure_ascii=False, sort_keys=True, separators=(",", ":"), allow_nan=False) + "\n")
+    result = {
+        "status": "pass",
+        "builder": Path(__file__).name,
+        "builder_sha256": sha256(Path(__file__)),
+        "output": str(OUTPUT.relative_to(ROOT)),
+        "output_sha256": sha256(OUTPUT),
+        "baseline_ui_data_sha256": EXPECTED_UI_SHA256,
+        "counts": sidecar["cpp"]["counts"],
+        "pair_status": dict(sorted(pair_status_counts.items())),
+        "legacy_extra_families": legacy_extras,
+    }
+    (HERE / "BUILD_RESULT.json").write_text(json.dumps(result, ensure_ascii=False, indent=2, sort_keys=True) + "\n")
+    (HERE / "REPORT.md").write_text(
+        "# C++ latest accepted view\n\n"
+        f"Status: **PASS** (derived view validation)\n\n"
+        f"The sidecar selects `{len(selected_rows)}` frozen compact rows by raw index and contains no copied numeric measurements. "
+        f"It records all `{len(authority)}` Native85 pair conclusions: `{pair_status_counts['numeric']}` numeric, "
+        f"`{pair_status_counts['not_applicable']}` N/A, and `{pair_status_counts['unsupported']}` unsupported. "
+        f"It also preserves `{len(legacy_extras)}` concrete legacy-only families.\n\n"
+        "Pair selection is atomic by dataset and canonical family. Corrected-five conclusions supersede every prior version, including missing-overall and all-unsupported tombstones. "
+        "Timing rankings use only unchanged rows already marked `timing_admitted_*`.\n\n"
+        f"Output SHA-256: `{result['output_sha256']}`\n"
+    )
+    print(json.dumps(result, ensure_ascii=False, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

cpp-latest-view.json

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

index.html

@@ -6,8 +6,8 @@
   <meta name="description" content="THULab time-series compression benchmark: measured compression rates, compression and decompression costs, and dataset coverage.">
   <meta name="color-scheme" content="light dark">
   <title>THULab | Time Series Compression Benchmark</title>
-  <link rel="stylesheet" href="style.css?v=20261013-corrected-five-v1">
-  <script src="app.js?v=20261013-corrected-five-v1" type="module"></script>
+  <link rel="stylesheet" href="style.css?v=20261013-cpp-latest-v1">
+  <script src="app.js?v=20261013-cpp-latest-v7" type="module"></script>
 </head>
 <body>
   <a class="skip-link" href="#content">Skip to results</a>
@@ -16,7 +16,7 @@
     <div class="header-links"><a href="https://github.com/xjz17/web_compression" target="_blank" rel="noopener">Project code ↗</a><button id="theme" class="quiet-button" type="button" aria-label="Switch color theme">Theme</button></div>
   </header>
   <main id="content">
-<section class="snapshot-notice" aria-label="Corrected input results"><strong>Corrected numeric inputs · 5 datasets</strong><p>425 algorithm–dataset conclusions: 386 pairs contain numerical results, 39 pairs contain only unsupported conclusions; 40 of the numerical pairs also contain N/A or unsupported column conclusions. FreshRetailNet-50K full114 is pending a new run. Earlier input versions remain available as separate profiles. Corrected-input timing is not admitted to timing or composite rankings.</p><a href="?profile=cpp-native166-corrected-five-20261012-v1#overall">View corrected-input results</a></section>
+<section class="snapshot-notice" aria-label="Current C++ result selection"><strong>C++ · latest receipt-bound result per dataset and method</strong><p>The C++ view combines published campaigns and selects the newest receipt-bound authority for each logical dataset/method pair. Corrected inputs for five datasets are included; terminal N/A or unsupported conclusions block fallback to older numbers. Prior versions remain preserved in the downloadable snapshot and evidence. FreshRetailNet-50K full114 is still pending and is not presented as a newer result.</p><a href="?profile=cpp#overall">View combined C++ results</a></section>
 
     <section class="intro" aria-labelledby="title">
       <p class="eyebrow">Time-series systems research</p>
@@ -26,9 +26,9 @@
     </section>
     <div class="summary-strip" id="summary" aria-label="Snapshot coverage">
       <div><strong id="dataset-count">…</strong><span id="dataset-count-label">measured datasets</span></div>
-      <div><strong id="method-count">…</strong><span>method families</span></div>
-      <div><strong id="runtime-count">…</strong><span>comparison profiles</span></div>
-      <div><strong id="record-count">…</strong><span>profile / codec configurations</span></div>
+      <div><strong id="method-count">…</strong><span>method families in selection</span></div>
+      <div><strong id="runtime-count">…</strong><span>implementation languages</span></div>
+      <div><strong id="record-count">…</strong><span>language / family / configurations</span></div>
     </div>
     <nav class="tabs" aria-label="Benchmark views">
       <button id="tab-overall" class="tab active" data-tab="overall" aria-current="page">🏅 Overall</button>
@@ -52,7 +52,7 @@
         <div id="dataset-catalog" class="dataset-catalog"></div>
       </section>
       <div class="filters" id="filters">
-        <label>Comparison profile<select id="runtime"></select></label>
+        <label>Implementation language<select id="runtime"></select></label>
         <label>Data type<select id="dtype"><option value="overall">Available numeric</option><option value="int">Integer</option><option value="float">Floating point</option></select></label>
         <label>Float precision<select id="precision"><option value="all">All precision</option><option value="fixed">Fixed precision</option><option value="non_fixed">Non-fixed precision</option></select></label>
         <label>Dataset<select id="dataset"><option value="all">All datasets</option></select></label>
@@ -65,16 +65,19 @@
         <div class="toolbar-actions"><button id="reset" class="quiet-button">Reset filters</button><button id="download" class="primary-button" disabled>Download CSV</button></div>
       </div>
       <div class="results-note" id="results-note">Compression rate = compressed bytes / original bytes. Lower rates and lower ns/point are better. Compression and decompression costs use equal-column arithmetic means where column timings are available. Methods with aggregate-only timings use equal-dataset arithmetic means for the selected range.</div>
+      <p id="profile-scope-note" class="profile-scope-note" aria-live="polite"></p>
+      <p id="availability-summary" class="availability-summary" aria-live="polite"></p>
       <div id="score-controls" class="score-controls">
         <label>Score weights · a: rate / b: compress / c: decompress<select id="weights" aria-label="Score weights a b c"></select></label>
         <p id="score-note" class="muted" aria-live="polite">Non-negative weights in steps of 0.1, summing to 1.0.</p>
       </div>
       <div class="table-settings">
         <label><input id="complete-only" type="checkbox"> Only methods covering the full selection</label>
+        <label><input id="show-unavailable-columns" type="checkbox"> Show unavailable metric columns</label>
         <details><summary>Display columns</summary><div id="column-options" class="column-options"></div></details>
       </div>
       <div id="chart-view" hidden>
-        <div class="chart-controls"><label>Vertical axis<select id="chart-metric"><option value="compression_time">Compression cost (ns/point)</option><option value="decompression_time">Decompression cost (ns/point)</option></select></label><span class="muted">Lower and further left is better. Click a point for method details.</span></div>
+        <div class="chart-controls"><label>Vertical axis<select id="chart-metric"><option value="compression_time_timed_subset">Compression cost · timed subset (ns/point)</option><option value="decompression_time_timed_subset">Decompression cost · timed subset (ns/point)</option><option value="compression_time">Strict compression cost (ns/point)</option><option value="decompression_time">Strict decompression cost (ns/point)</option></select></label><span class="muted">Timed-subset points are limited to one exact source profile, host, and timing contract; inspect N/M coverage before comparison.</span></div>
         <div id="chart" class="chart" aria-label="Compression rate and execution cost scatter plot"></div>
       </div>
       <div id="leaderboard-wrap" class="table-wrap" tabindex="0" aria-label="Scrollable sortable leaderboard">
@@ -116,13 +119,14 @@
       <dl class="definitions">
         <div><dt>Average compression rate ↓</dt><dd>Arithmetic mean of the per-dataset compression rates in the selected scope.</dd></div>
         <div><dt>Overall compression rate ↓</dt><dd>Total compressed bytes divided by total original bytes over the selected measured records.</dd></div>
-        <div><dt>Compression / decompression cost ↓</dt><dd>For each result with admitted column-level timing evidence, calculate ns/point independently for every usable numeric column, then take the arithmetic mean across those columns. Each column contributes equally. Overall timing pools all measured columns across the selected datasets when every selected dataset has column timings. If any selected dataset/configuration has only aggregate timing, use the arithmetic mean of the selected datasets' ns/point values instead, giving each dataset equal weight. For an aggregate-only dataset, ns/point comes from its recorded total elapsed time divided by its recorded point count. Missing and diagnostic-only timings remain unavailable. Method details and CSV identify the timing basis, exact source profile, and binary. Compare timings within the same host/campaign/measurement-contract profile.</dd></div>
+        <div><dt>Compression / decompression cost ↓</dt><dd>For each result with admitted column-level timing evidence, calculate ns/point independently for every usable numeric column, then take the arithmetic mean across those columns. Each column contributes equally. Strict timing requires every current rate dataset for a method to have eligible timing. Missing and diagnostic-only timings remain unavailable.</dd></div>
+        <div><dt>Timed-subset compression / decompression cost ↓</dt><dd>Uses only current winning rows with admitted timing, and only when those rows share one exact source profile, host, timing contract, and aggregation basis. Each value displays N / M: timed datasets divided by current rate datasets. It is descriptive and never enters strict composite scores.</dd></div>
         <div><dt>Coverage</dt><dd>Datasets with usable measurements for a method out of the measured datasets in the selected runtime, data type, and dataset selection. The summary dataset count uses the same selection. Missing results are never filled with zero.</dd></div>
         <div><dt>Composite score ↓</dt><dd>a × average compression rate + b × normalized average compression time + c × normalized average decompression time. A composite is published only when the displayed methods share one exact dataset and eligible aggregate-id support signature. If all times are equal, their normalized value is zero. All measured inputs must have usable timing metrics.</dd></div>
         <div><dt>Average Rank ↓</dt><dd>Compute the same weighted score only among methods with the same dataset and eligible aggregate-id support hash, normalizing times inside that matched cohort. Rank lower scores first; ties share their average position. Then take the arithmetic mean of the method's available matched-cohort ranks. Weights are non-negative tenths summing to 1.0. Missing, N/A, failed, and unlike-support measurements do not receive ranks.</dd></div>
       </dl>
       <h3>Reading the rankings</h3>
-      <p>Methods with different coverage are measured on different inputs. Coverage counts datasets, not identical columns or point counts. Use the full-coverage filter and inspect a single dataset's input sizes before drawing a direct comparison. Comparison profiles keep languages, hosts, campaigns, and measurement contracts separate.</p>
+      <p>Methods with different coverage are measured on different inputs. Coverage counts datasets, not identical columns or point counts. Use the full-coverage filter and inspect a single dataset's input sizes before drawing a direct comparison. The C++ view chooses the latest receipt-bound source for each dataset/method pair while preserving source profile and host in details and CSV. Java and Python remain separate language views.</p>
       <p>By default, each family selects the lowest-rate exact variant independently for each dataset only when all candidates for that dataset/family have one exact support set. This view can choose different binaries across datasets. Ambiguous support sets are omitted. Switch Method rows to Exact configuration to inspect fixed variants, source profiles, binaries, and support hashes.</p>
       <p>These are published measurements, not experiments executed inside this Space. A reported ratio alone does not establish lossless reconstruction; round-trip checks and hardware details are shown only when their evidence exists in the source snapshot. Timings without an exact admitted source/build/binary/boundary chain are unavailable to timing and composite rankings.</p>
       <h3>Download and provenance</h3>

style.css

@@ -19,3 +19,4 @@
 .snapshot-notice{margin:0 0 1.5rem;padding:1rem 1.25rem;border:1px solid var(--border,#cbd5e1);border-radius:12px}.snapshot-notice p{margin:.5rem 0;line-height:1.5}
 
 .operator-effect-results{margin:18px 0 26px;padding:18px;border:1px solid var(--line);border-radius:var(--radius);background:var(--surface)}.operator-effect-head{display:flex;align-items:start;justify-content:space-between;gap:20px}.operator-effect-head h3{margin:0 0 4px}.operator-effect-table-wrap{max-height:430px}.operator-effect-table-wrap th:first-child,.operator-effect-table-wrap td:first-child{text-align:left}.operator-effect-cost{color:#a34832}.operator-effect-saving{color:var(--accent)}@media(max-width:768px){.operator-effect-head{flex-direction:column}.operator-effect-head .quiet-button{width:100%;text-align:center}.operator-effect-table-wrap{max-height:520px}}
+.profile-scope-note,.availability-summary{margin:8px 0 0;padding:10px 12px;border-left:3px solid var(--accent);background:var(--accent-soft);color:var(--text);font-size:12px;line-height:1.5}.availability-summary{margin-top:6px;border-left-color:var(--line);background:var(--soft);color:var(--muted)}.unavailable-value{color:var(--muted);font-family:inherit;font-size:11px;white-space:normal}.metric-coverage{display:inline-block;margin-left:5px;padding:1px 5px;border-radius:999px;background:var(--soft);color:var(--muted);font-family:inherit;font-size:9px}.detail-grid{grid-template-columns:repeat(3,1fr)}