Publish independently accepted native328 recovery completion

Integrate all 328 independently accepted native recovery pairs into the 164-dataset, 85-method snapshot. The reconciled 502 problem pairs are accepted with zero unresolved pairs. Preserve exact support and comparison profiles; recovery timing remains diagnostic only with public timing fields null. Operator-effect recovery and Fig11 remain pending separately.

NATIVE86_ACCEPTED_COMPLETION_V7.json

@@ -0,0 +1,46 @@
+{
+  "base_v6_freeze_receipt_sha256": "f84eb814b8c962939c119cadbc97594a3bffd3174ebe817e9d36d27ecf61617a",
+  "boundaries": {
+    "adapter_identity": "configuration plus binary SHA prefix in algorithm_variant",
+    "binary_sha256": [
+      "d528da93470af747b3ecf6cfd9a9b4c883f07caf74731f03e00320a8b583b8fb"
+    ],
+    "campaign_actions": [
+      "rerun_v4",
+      "reuse_v3_recovered"
+    ],
+    "comparison_profiles": [
+      "cpp-native166-current-recovery-v3-baseline86-fixed-profiles-20260919-v3",
+      "cpp-native166-row-support-v4-baseline86-fixed-profiles-20260919-v3"
+    ],
+    "exact_source_profiles": [
+      "cpp-native166-current-recovery-v3-d528da93",
+      "cpp-native166-row-support-v4-d528da93"
+    ],
+    "execution_host": "166.111.68.166",
+    "support_identity": "exact sorted aggregate-id SHA-256",
+    "timing": "diagnostic only; all public timing fields null"
+  },
+  "counts": {
+    "accepted_completion_pairs": 328,
+    "accepted_unique_repair_pairs": 502,
+    "base_publish_files": 28,
+    "completion_dataset_result_rows": 804,
+    "dataset_result_rows": 91701,
+    "original_problem_pairs": 502,
+    "unresolved_problem_pairs": 0
+  },
+  "created_at": "2026-10-11T13:27:00.624157+00:00",
+  "files": {
+    "data.json": "fd2b20a29b87e4703fcc6601ee3bea2f5eb62f7c145291373aded904430bba73",
+    "manifest.json": "585786432128af028508eae9b11ba4e681a84cdb7e02a99e949e665c8720dde4",
+    "native86-coverage.json": "cfa7a03c1c4d6a2031000595f61bcd55b8bd9b366a0e192bfa78e5754e7408c3",
+    "native86-recovery-reconciliation.json": "617930f89371d33fa8b4428824f155391daba29051b5a97504aeaef510b37f01",
+    "ui-data.json": "60645d3d9240a5e461c27dc92933374f84de0dbd8a3777c1a6f2288acc8c914a"
+  },
+  "independent_acceptance_sha256": "801b1f024ccf2adf08f5b948038c9c443f5e6de059190efb7c3a870c0c57ef77",
+  "portable_manifest_sha256": "0f3334e929beceb683ada70b7df9f38ec6c007491525c586495de5e31c6f6cbe",
+  "portable_records_sha256": "fc01b845db5a54b90555ec25dfb0c363bf1abea6bc2d1c8f025d5424df08a714",
+  "schema": "compressionbenchmark-native86-accepted-completion-integration-v1",
+  "status": "passed_not_published"
+}

README.md

@@ -71,3 +71,7 @@ Source project: https://github.com/xjz17/web_compression
 
 
 The timing updater verifies the input hashes, replaces existing dataset/runtime/scope rows by identity, and adds only missing rows. The measurement harness and its frozen-source instructions are in `scripts/dbp_medium_posts_retest/`; raw data and compiled binaries are excluded from Git.
+
+## Native86 accepted completion v7
+
+The independently accepted 328-pair completion closes the 502 original Native86 problem identities for rate/byte reporting. Completion timing remains diagnostic and is excluded from timing and composite rankings. Host, campaign action, binary, adapter configuration and exact eligible support are retained as separate comparison dimensions.

build_accepted_completion_v7.py

@@ -0,0 +1,957 @@
+#!/usr/bin/env python3
+"""Export and merge an independently accepted Native86 328-pair completion.
+
+The command has two stages:
+
+* ``export`` runs beside the accepted server artifacts.  It rehashes the
+  independent acceptance, manifest, pair receipts, result files and cold files
+  and emits a portable, path-free bundle.
+* ``build`` runs locally.  It verifies the frozen v6 base and portable bundle,
+  requires the accepted identities to equal the exact 328 unresolved v6
+  identities, then creates a new v7 candidate directory.
+
+Timing from the completion is always diagnostic and is set to null in public
+ranking fields.  Exact host, campaign action, binary, adapter configuration and
+eligible aggregate support remain separate dimensions.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as dt
+import gzip
+import hashlib
+import json
+import math
+import os
+import shutil
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any, Iterable
+
+
+EXPECTED_BASE_SCHEMA = "compressionbenchmark-site-v6-freeze-receipt-v1"
+EXPECTED_BASE_STATUS = "passed_not_published"
+EXPECTED_BASE_FILES = 28
+EXPECTED_ACCEPTANCE_SCHEMA = "paper164-native86-row-support-independent-acceptance-v4"
+EXPECTED_MANIFEST_SCHEMA = "paper164-native86-row-support-sidecar-manifest-v4"
+EXPECTED_UNIVERSE = 328
+HOST166 = "166.111.68.166"
+ALLOWED_ACTIONS = {"reuse_v3_recovered", "rerun_v4"}
+ALLOWED_STATUSES = {"ok", "N/A", "unsupported"}
+
+
+def fail(message: str) -> None:
+    raise ValueError(message)
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 << 20), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def canonical_sha(values: Iterable[str]) -> str:
+    payload = json.dumps(sorted(values), ensure_ascii=False, separators=(",", ":"))
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+def read_object(path: Path) -> dict[str, Any]:
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(value, dict):
+        fail(f"expected JSON object: {path}")
+    return value
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open(encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, 1):
+            if not line.strip():
+                continue
+            value = json.loads(line)
+            if not isinstance(value, dict):
+                fail(f"expected object at {path}:{line_number}")
+            rows.append(value)
+    return rows
+
+
+def read_gzip_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with gzip.open(path, "rt", encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, 1):
+            if not line.strip():
+                continue
+            value = json.loads(line)
+            if not isinstance(value, dict):
+                fail(f"expected object at {path}:{line_number}")
+            rows.append(value)
+    return rows
+
+
+def write_gzip_jsonl(path: Path, rows: Iterable[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("xb") as raw:
+        with gzip.GzipFile(filename="", mode="wb", fileobj=raw, mtime=0) as zipped:
+            for row in rows:
+                zipped.write(
+                    (json.dumps(row, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + "\n")
+                    .encode("utf-8")
+                )
+
+
+def finite(value: Any, *, positive: bool = False) -> float:
+    number = float(value)
+    if not math.isfinite(number) or (positive and number <= 0):
+        fail(f"invalid numeric value: {value!r}")
+    return number
+
+
+def safe_relative(value: str) -> Path:
+    path = Path(value)
+    if path.is_absolute() or ".." in path.parts or value in {"", "."}:
+        fail(f"unsafe relative path: {value!r}")
+    return path
+
+
+def parse_path_maps(values: list[str]) -> list[tuple[Path, Path]]:
+    mappings: list[tuple[Path, Path]] = []
+    for value in values:
+        if "=" not in value:
+            fail(f"path map must be OLD=NEW: {value!r}")
+        old, new = value.split("=", 1)
+        mappings.append((Path(old).resolve(), Path(new).resolve()))
+    return sorted(mappings, key=lambda item: len(str(item[0])), reverse=True)
+
+
+def mapped_path(value: Any, mappings: list[tuple[Path, Path]]) -> Path:
+    source = Path(str(value))
+    if not source.is_absolute():
+        return source.resolve()
+    resolved = source.resolve()
+    for old, new in mappings:
+        try:
+            return new / resolved.relative_to(old)
+        except ValueError:
+            continue
+    return resolved
+
+
+def verify_hash(path: Path, expected: Any, label: str) -> None:
+    if not path.is_file() or sha256(path) != expected:
+        fail(f"{label} path/SHA mismatch: {path}")
+
+
+def expected_unresolved(reconciliation: dict[str, Any]) -> set[tuple[str, str]]:
+    counts = reconciliation.get("counts") or {}
+    if (
+        reconciliation.get("schema") != "paper164-recovery-key-reconciliation-v1"
+        or int(counts.get("current_unresolved_pairs", -1)) != EXPECTED_UNIVERSE
+        or int(counts.get("accepted_unique_repair_pairs", -1)) != 174
+        or int(counts.get("original_active_problem_pairs", -1)) != 502
+    ):
+        fail("v6 recovery reconciliation count/schema drift")
+    rows = [*(reconciliation.get("current327_pair_identities") or [])]
+    rows.extend(reconciliation.get("omitted_unresolved") or [])
+    identities = {(str(row["dataset_id"]), str(row["method"])) for row in rows}
+    if len(identities) != EXPECTED_UNIVERSE:
+        fail("v6 unresolved identity set is not exactly 328")
+    accepted = {
+        (str(row["dataset_id"]), str(row["method"]))
+        for row in reconciliation.get("accepted_pair_identities") or []
+    }
+    if identities & accepted:
+        fail("v6 unresolved and already accepted repair identities overlap")
+    return identities
+
+
+def validate_acceptance(
+    acceptance: dict[str, Any], manifest: dict[str, Any],
+    acceptance_path: Path, manifest_path: Path,
+) -> tuple[list[dict[str, Any]], dict[str, dict[str, Any]]]:
+    if (
+        acceptance.get("schema") != EXPECTED_ACCEPTANCE_SCHEMA
+        or acceptance.get("status") != "accepted"
+        or int(acceptance.get("accepted_universe_count", -1)) != EXPECTED_UNIVERSE
+        or acceptance.get("active_campaign_processes") != []
+    ):
+        fail("independent acceptance is not final/clean for all 328 pairs")
+    manifest_ref = acceptance.get("manifest") or {}
+    if manifest_ref.get("sha256") != sha256(manifest_path):
+        fail("acceptance does not bind the supplied v4 manifest SHA")
+    if (
+        manifest.get("schema") != EXPECTED_MANIFEST_SCHEMA
+        or manifest.get("status") != "approved_for_append_only_execution"
+        or len(manifest.get("candidates") or []) != EXPECTED_UNIVERSE
+    ):
+        fail("v4 manifest schema/status/universe drift")
+    evidence = acceptance.get("pair_evidence") or []
+    if len(evidence) != EXPECTED_UNIVERSE:
+        fail("acceptance pair evidence count is not 328")
+    by_key = {str(row["selection_key_hex"]): row for row in manifest["candidates"]}
+    if len(by_key) != EXPECTED_UNIVERSE:
+        fail("manifest selection keys are not unique")
+    evidence_keys = [str(row.get("selection_key_hex")) for row in evidence]
+    if len(set(evidence_keys)) != EXPECTED_UNIVERSE or set(evidence_keys) != set(by_key):
+        fail("acceptance and manifest selection-key universes differ")
+    for row in evidence:
+        candidate = by_key[str(row["selection_key_hex"])]
+        if (
+            row.get("action") not in ALLOWED_ACTIONS
+            or row.get("dataset_id") != candidate.get("dataset_id")
+            or row.get("method") != candidate.get("method")
+            or (row.get("row_support") or {}).get("status") != "accepted"
+        ):
+            fail("acceptance evidence identity/action/status mismatch")
+    return evidence, by_key
+
+
+def validate_pair_files(
+    candidate: dict[str, Any], evidence: dict[str, Any], receipt: dict[str, Any],
+    result_rows: list[dict[str, Any]], cold_rows: list[dict[str, Any]],
+) -> None:
+    dataset, method = str(candidate["dataset_id"]), str(candidate["method"])
+    if (
+        receipt.get("dataset_id") != dataset
+        or receipt.get("method") != method
+        or receipt.get("method_id") != candidate.get("method_id")
+        or receipt.get("selection_key") != candidate.get("selection_key")
+    ):
+        fail(f"receipt identity mismatch for {dataset}/{method}")
+    result_by_id = {str(row.get("aggregate_id")): row for row in result_rows}
+    cold_by_id = {str(row.get("aggregate_id")): row for row in cold_rows}
+    if len(result_by_id) != len(result_rows) or len(cold_by_id) != len(cold_rows):
+        fail(f"duplicate aggregate id for {dataset}/{method}")
+    statuses = Counter(str(row.get("status")) for row in result_rows)
+    if not set(statuses) <= ALLOWED_STATUSES:
+        fail(f"unaccepted result status for {dataset}/{method}: {dict(statuses)}")
+    declared = (evidence.get("row_support") or {}).get("result_status_counts") or {}
+    if dict(sorted(statuses.items())) != declared:
+        fail(f"result status counts differ from acceptance for {dataset}/{method}")
+    supported_ids = {
+        aggregate_id for aggregate_id, row in result_by_id.items()
+        if row.get("status") in {"ok", "N/A"}
+    }
+    if set(cold_by_id) != supported_ids:
+        fail(f"cold coverage differs from supported rows for {dataset}/{method}")
+    configurations = set()
+    for aggregate_id, row in result_by_id.items():
+        if row.get("dataset_id") != dataset or row.get("method") != method:
+            fail(f"result identity mismatch for {aggregate_id}")
+        configurations.add(str(row.get("configuration")))
+        status = row["status"]
+        if status == "ok":
+            original = int(row.get("original_numeric_bytes", 0))
+            compressed = int(row.get("complete_frame_bytes", 0))
+            if original <= 0 or compressed <= 0:
+                fail(f"non-positive measured bytes for {aggregate_id}")
+            if not math.isclose(
+                finite(row.get("compression_ratio"), positive=True),
+                compressed / original, rel_tol=2e-12, abs_tol=0.0,
+            ):
+                fail(f"compression ratio mismatch for {aggregate_id}")
+        elif status == "N/A" and int(row.get("original_numeric_bytes", -1)) != 0:
+            fail(f"N/A row has numeric payload for {aggregate_id}")
+        if status in {"ok", "N/A"}:
+            cold = cold_by_id[aggregate_id]
+            if (
+                cold.get("status") != "ok"
+                or cold.get("fresh_process") is not True
+                or cold.get("dataset_id") != dataset
+                or cold.get("method") != method
+                or cold.get("complete_frame_sha256") != row.get("complete_frame_sha256")
+            ):
+                fail(f"cold verification mismatch for {aggregate_id}")
+    if len(configurations) != 1:
+        fail(f"pair spans multiple adapter configurations: {dataset}/{method}")
+
+
+def export_portable(args: argparse.Namespace) -> dict[str, Any]:
+    acceptance_path = args.acceptance.resolve()
+    manifest_path = args.v4_manifest.resolve()
+    verify_hash(acceptance_path, args.expected_acceptance_sha256, "independent acceptance")
+    acceptance, manifest = read_object(acceptance_path), read_object(manifest_path)
+    evidence_rows, candidates = validate_acceptance(
+        acceptance, manifest, acceptance_path, manifest_path,
+    )
+    reconciliation = read_object(args.v6_reconciliation)
+    expected = expected_unresolved(reconciliation)
+    actual = {(str(row["dataset_id"]), str(row["method"])) for row in evidence_rows}
+    if actual != expected:
+        fail("accepted pair identities do not equal the exact v6 unresolved universe")
+
+    output = args.output_dir.resolve()
+    if output.exists():
+        fail(f"refuse to replace portable export directory: {output}")
+    output.mkdir(parents=True)
+    mappings = parse_path_maps(args.path_map)
+    portable_rows: list[dict[str, Any]] = []
+    action_counts: Counter[str] = Counter()
+    aggregate_status_counts: Counter[str] = Counter()
+    for evidence in sorted(evidence_rows, key=lambda row: str(row["selection_key_hex"])):
+        key = str(evidence["selection_key_hex"])
+        candidate = candidates[key]
+        receipt_ref = (evidence.get("evidence") or {}).get("receipt") or {}
+        receipt_path = mapped_path(receipt_ref.get("path"), mappings)
+        verify_hash(receipt_path, receipt_ref.get("sha256"), "accepted pair receipt")
+        receipt = read_object(receipt_path)
+        result_path = mapped_path(receipt.get("result_path"), mappings)
+        cold_path = mapped_path(receipt.get("cold_path"), mappings)
+        verify_hash(result_path, receipt.get("result_sha256"), "accepted result")
+        verify_hash(cold_path, receipt.get("cold_sha256"), "accepted cold result")
+        results, cold = read_jsonl(result_path), read_jsonl(cold_path)
+        validate_pair_files(candidate, evidence, receipt, results, cold)
+        action = str(evidence["action"])
+        binary_sha = str(receipt.get("binary_sha256") or "")
+        if len(binary_sha) != 64:
+            fail(f"accepted pair lacks exact binary SHA: {candidate['selection_key']}")
+        versions = {str(row.get("profile_version") or manifest.get("profile_version")) for row in results}
+        if len(versions) != 1:
+            fail(f"accepted pair spans multiple profiles: {candidate['selection_key']}")
+        action_counts[action] += 1
+        aggregate_status_counts.update(str(row["status"]) for row in results)
+        portable_rows.append({
+            "schema": "compressionbenchmark-native328-portable-pair-v1",
+            "selection_key_hex": key,
+            "dataset_id": candidate["dataset_id"],
+            "method": candidate["method"],
+            "method_id": candidate["method_id"],
+            "action": action,
+            "binary_sha256": binary_sha,
+            "profile_version": next(iter(versions)),
+            "receipt_sha256": receipt_ref["sha256"],
+            "result_sha256": receipt["result_sha256"],
+            "cold_sha256": receipt["cold_sha256"],
+            "row_support": evidence["row_support"],
+            "result_rows": results,
+        })
+
+    records_path = output / "native86-row-support-v4-portable-results.jsonl.gz"
+    write_gzip_jsonl(records_path, portable_rows)
+    portable_manifest = {
+        "schema": "compressionbenchmark-native328-portable-manifest-v1",
+        "status": "accepted_portable_export",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "independent_acceptance": {
+            "sha256": sha256(acceptance_path),
+            "schema": acceptance["schema"],
+            "status": acceptance["status"],
+            "accepted_universe_count": EXPECTED_UNIVERSE,
+        },
+        "v4_manifest": {
+            "sha256": sha256(manifest_path),
+            "schema": manifest["schema"],
+            "profile_version": manifest["profile_version"],
+        },
+        "v6_reconciliation_sha256": sha256(args.v6_reconciliation),
+        "pair_count": len(portable_rows),
+        "action_counts": dict(sorted(action_counts.items())),
+        "aggregate_status_counts": dict(sorted(aggregate_status_counts.items())),
+        "pair_identity_sha256": canonical_sha(f"{dataset}\0{method}" for dataset, method in expected),
+        "timing_policy": "diagnostic_only_public_ranking_fields_null_until_separate_exact_timing_admission",
+        "records": {
+            "path": records_path.name,
+            "sha256": sha256(records_path),
+            "row_count": len(portable_rows),
+        },
+    }
+    manifest_output = output / "native86-row-support-v4-portable-manifest.json"
+    manifest_output.write_text(
+        json.dumps(portable_manifest, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    return portable_manifest
+
+
+def dtype_scope(dtype: str) -> str:
+    value = dtype.casefold()
+    if value.startswith("float"):
+        return "float"
+    if value.startswith("int") or value.startswith("uint"):
+        return "integer"
+    fail(f"unsupported numeric dtype: {dtype}")
+
+
+def profile_slug(value: Any) -> str:
+    return "".join(character if character.isalnum() else "-" for character in str(value).lower()).strip("-")
+
+
+def action_slug(action: str) -> str:
+    return "current-recovery-v3" if action == "reuse_v3_recovered" else "row-support-v4"
+
+
+def rows_for_pair(pair: dict[str, Any], acceptance_sha: str) -> list[dict[str, Any]]:
+    measured = [row for row in pair["result_rows"] if row.get("status") == "ok"]
+    if not measured:
+        return []
+    dataset, family = str(pair["dataset_id"]), str(pair["method"])
+    binary_sha = str(pair["binary_sha256"])
+    configuration = str(measured[0]["configuration"])
+    if any(str(row.get("configuration")) != configuration for row in measured):
+        fail(f"adapter configuration drift for {dataset}/{family}")
+    exact_runtime = f"cpp-native166-{action_slug(pair['action'])}-{binary_sha[:8]}"
+    comparison = f"cpp-native166-{action_slug(pair['action'])}-{profile_slug(pair['profile_version'])}"
+    groups: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for row in measured:
+        groups[dtype_scope(str(row["dtype"]))].append(row)
+    # Overall is valid only when every aggregate in the accepted catalog has
+    # numeric support.  Mixed N/A/unsupported support must remain absent.
+    if len(measured) == len(pair["result_rows"]):
+        groups["overall"] = list(measured)
+    output: list[dict[str, Any]] = []
+    for scope, source in sorted(groups.items()):
+        original = sum(int(row["original_numeric_bytes"]) for row in source)
+        compressed = sum(int(row["complete_frame_bytes"]) for row in source)
+        points = sum(int(row["row_count"]) for row in source)
+        diagnostic = {
+            "compression_time_ns": sum(finite(row["compression_ns"]) for row in source),
+            "decompression_time_ns": sum(finite(row["decompression_ns"]) for row in source),
+            "timing_column_count": len(source),
+            "timing_aggregation": "column_mean",
+            "reason": "independent rate/bytes acceptance does not separately admit an exact timing boundary",
+        }
+        output.append({
+            "dataset": dataset,
+            "scope": scope,
+            "runtime": exact_runtime,
+            "comparison_profile": comparison,
+            "method": configuration,
+            "family": family,
+            "algorithm_variant": f"{configuration} [{binary_sha[:8]}]",
+            "is_best_rate_in_family": True,
+            "original_size_bytes": original,
+            "compressed_size_bytes": compressed,
+            "point_count": points,
+            "compression_rate": compressed / original,
+            "compression_time_ns": None,
+            "decompression_time_ns": None,
+            "compression_time_ns_per_point": None,
+            "decompression_time_ns_per_point": None,
+            "timing_column_count": 0,
+            "timing_aggregation": "unavailable",
+            "diagnostic_timing": diagnostic,
+            "eligible_dtype_scope": scope,
+            "eligible_column_set_sha256": canonical_sha(str(row["aggregate_id"]) for row in source),
+            "eligible_column_set_status": "exact_sorted_aggregate_ids_sha256",
+            "measurement_status": "independent_row_support_acceptance_result_cold_sha_bound",
+            "timing_profile_status": "timing_diagnostic_rate_bytes_accepted_without_separate_timing_admission",
+            "execution_host": HOST166,
+            "campaign_action": pair["action"],
+            "binary_sha256": binary_sha,
+            "profile_version": pair["profile_version"],
+            "acceptance_sha256": acceptance_sha,
+            "receipt_sha256": pair["receipt_sha256"],
+            "result_sha256": pair["result_sha256"],
+            "cold_sha256": pair["cold_sha256"],
+        })
+    return output
+
+
+def aggregate_rows(
+    rows: list[dict[str, Any]], *, runtime: str, scope: str,
+    method: str, family: str, variant: str | None,
+) -> dict[str, Any]:
+    original = sum(row["original_size_bytes"] for row in rows)
+    compressed = sum(row["compressed_size_bytes"] for row in rows)
+    points = sum(row["point_count"] for row in rows)
+    timing_valid = all(
+        row.get("compression_time_ns_per_point") is not None
+        and row.get("decompression_time_ns_per_point") is not None
+        and str(row.get("timing_profile_status", "")).startswith("timing_admitted_")
+        for row in rows
+    )
+    timing_columns = sum(int(row.get("timing_column_count", 0)) for row in rows) if timing_valid else 0
+    return {
+        "runtime": runtime,
+        "scope": scope,
+        "method": method,
+        "family": family,
+        "algorithm_variant": variant,
+        "dataset_count": len(rows),
+        "overall_compression_rate": compressed / original,
+        "average_compression_rate": sum(row["compression_rate"] for row in rows) / len(rows),
+        "weighted_compression_time_ns_per_point": (
+            sum(row["compression_time_ns"] for row in rows) / points if timing_valid and points else None
+        ),
+        "average_compression_time_ns_per_point": (
+            sum(row["compression_time_ns_per_point"] * row["timing_column_count"] for row in rows) / timing_columns
+            if timing_valid and timing_columns else None
+        ),
+        "weighted_decompression_time_ns_per_point": (
+            sum(row["decompression_time_ns"] for row in rows) / points if timing_valid and points else None
+        ),
+        "average_decompression_time_ns_per_point": (
+            sum(row["decompression_time_ns_per_point"] * row["timing_column_count"] for row in rows) / timing_columns
+            if timing_valid and timing_columns else None
+        ),
+        "timing_column_count": timing_columns,
+        "timing_aggregation": "column_mean" if timing_valid and timing_columns else "unavailable",
+        "timing_dataset_count": len(rows),
+        "original_size_bytes": original,
+        "compressed_size_bytes": compressed,
+        "point_count": points,
+    }
+
+
+def recompute(data: dict[str, Any]) -> None:
+    rows = data["dataset_results"]
+    configurations: dict[tuple[str, str, str, str], list[dict[str, Any]]] = defaultdict(list)
+    candidates: dict[tuple[str, str, str, str], list[dict[str, Any]]] = defaultdict(list)
+    for row in rows:
+        profile = str(row.get("comparison_profile", row["runtime"]))
+        configurations[profile, row["scope"], row["family"], row["algorithm_variant"]].append(row)
+        candidates[profile, row["scope"], row["dataset"], row["family"]].append(row)
+    family_rows: list[dict[str, Any]] = []
+    ambiguous = 0
+    for group in candidates.values():
+        if len({str(row["eligible_column_set_sha256"]) for row in group}) != 1:
+            ambiguous += 1
+            continue
+        family_rows.append(min(group, key=lambda row: (row["compression_rate"], row["method"])))
+    families: dict[tuple[str, str, str], list[dict[str, Any]]] = defaultdict(list)
+    for row in family_rows:
+        profile = str(row.get("comparison_profile", row["runtime"]))
+        families[profile, row["scope"], row["family"]].append(row)
+    data["configuration_aggregates"] = [
+        aggregate_rows(source, runtime=runtime, scope=scope, family=family, method=variant, variant=variant)
+        for (runtime, scope, family, variant), source in sorted(configurations.items())
+    ]
+    data["family_best_aggregates"] = [
+        aggregate_rows(source, runtime=runtime, scope=scope, family=family, method=family, variant=None)
+        for (runtime, scope, family), source in sorted(families.items())
+    ]
+    data["family_best_support_contract"] = {
+        "status": "passed",
+        "selection": "one support hash per comparison-profile/scope/dataset/family before lowest-rate selection",
+        "omitted_ambiguous_dataset_family_groups": ambiguous,
+    }
+
+
+def build_ui_payload(data: dict[str, Any], data_sha: str) -> dict[str, Any]:
+    rows = data["dataset_results"]
+    fields = {
+        "datasets": "dataset", "scopes": "scope", "runtimes": "runtime",
+        "comparison_profiles": "comparison_profile", "families": "family",
+        "configurations": "algorithm_variant",
+    }
+    tables = {key: sorted({row[field] for row in rows}) for key, field in fields.items()}
+    tables["timing_aggregations"] = sorted({row["timing_aggregation"] for row in rows})
+    tables["support_sets"] = sorted({row.get("eligible_column_set_sha256", "legacy_snapshot_unbound") for row in rows})
+    tables["measurement_statuses"] = sorted({row.get("measurement_status", "legacy_published_measurement") for row in rows})
+    tables["timing_statuses"] = sorted({row.get("timing_profile_status", "source_snapshot_timing") for row in rows})
+    tables["binary_hashes"] = sorted({row.get("binary_sha256") or "unbound" for row in rows})
+    indices = {key: {value: index for index, value in enumerate(values)} for key, values in tables.items()}
+    compact = []
+    for row in rows:
+        compact.append([
+            *(indices[key][row[field]] for key, field in fields.items()),
+            row["compression_rate"], row["compression_time_ns_per_point"],
+            row["decompression_time_ns_per_point"], row["original_size_bytes"],
+            row["compressed_size_bytes"], row.get("timing_column_count", 0),
+            indices["timing_aggregations"][row["timing_aggregation"]],
+            indices["support_sets"][row.get("eligible_column_set_sha256", "legacy_snapshot_unbound")],
+            indices["measurement_statuses"][row.get("measurement_status", "legacy_published_measurement")],
+            indices["timing_statuses"][row.get("timing_profile_status", "source_snapshot_timing")],
+            indices["binary_hashes"][row.get("binary_sha256") or "unbound"],
+        ])
+    payload = {key: data[key] for key in ("schema_version", "benchmark", "coverage", "datasets", "methods", "scopes", "source")}
+    if "dataset_summary" in data:
+        payload["dataset_summary"] = data["dataset_summary"]
+    payload.update(
+        exported_at=dt.datetime.now(dt.timezone.utc).isoformat(),
+        source_data_sha256=data_sha,
+        record_tables=tables,
+        compact_records=compact,
+    )
+    return payload
+
+
+def verify_base(base: Path, freeze_path: Path) -> dict[str, str]:
+    freeze = read_object(freeze_path)
+    files = freeze.get("publish_files")
+    if (
+        freeze.get("schema") != EXPECTED_BASE_SCHEMA
+        or freeze.get("status") != EXPECTED_BASE_STATUS
+        or not isinstance(files, dict)
+        or len(files) != EXPECTED_BASE_FILES
+    ):
+        fail("base v6 freeze receipt is not the exact 28-file frozen release")
+    for name, expected in files.items():
+        relative = safe_relative(str(name))
+        verify_hash(base / relative, expected, f"base v6 {relative}")
+    return {str(name): str(value) for name, value in files.items()}
+
+
+def update_methods(data: dict[str, Any], rows: list[dict[str, Any]]) -> None:
+    method_map = {(str(item["name"]), str(item["family"])): item for item in data["methods"]}
+    family_examples = {str(item["family"]): item for item in data["methods"]}
+    for row in rows:
+        key = str(row["algorithm_variant"]), str(row["family"])
+        item = method_map.get(key)
+        if item is None:
+            example = family_examples.get(key[1], {})
+            item = {
+                "name": key[0], "family": key[1], "runtimes": [],
+                "operator_pipeline": example.get("operator_pipeline"),
+                "operator_pipeline_status": example.get("operator_pipeline_status", "not_available"),
+            }
+            data["methods"].append(item)
+            method_map[key] = item
+        profile = str(row["comparison_profile"])
+        if profile not in item["runtimes"]:
+            item["runtimes"].append(profile)
+    data["methods"] = sorted(data["methods"], key=lambda item: (item["family"], item["name"]))
+
+
+def completion_profile_summaries(rows: list[dict[str, Any]], pairs: list[dict[str, Any]]) -> tuple[dict[str, Any], dict[str, Any]]:
+    profile_summary: dict[str, Any] = {}
+    for runtime in sorted({str(row["runtime"]) for row in rows}):
+        selected = [row for row in rows if row["runtime"] == runtime]
+        selected_pairs = [pair for pair in pairs if runtime.endswith(str(pair["binary_sha256"])[:8]) and action_slug(pair["action"]) in runtime]
+        profile_summary[runtime] = {
+            "execution_host": HOST166,
+            "pair_count": len(selected_pairs),
+            "aggregate_count": sum(len(pair["result_rows"]) for pair in selected_pairs),
+            "dataset_result_count": len(selected),
+            "binary_sha256": selected[0]["binary_sha256"],
+            "timing_profile_status": selected[0]["timing_profile_status"],
+            "comparison_profiles": sorted({row["comparison_profile"] for row in selected}),
+        }
+    comparison_summary: dict[str, Any] = {}
+    for profile in sorted({str(row["comparison_profile"]) for row in rows}):
+        selected = [row for row in rows if row["comparison_profile"] == profile]
+        pair_ids = {(row["dataset"], row["family"], row["algorithm_variant"]) for row in selected}
+        comparison_summary[profile] = {
+            "execution_host": HOST166,
+            "pair_count": len(pair_ids),
+            "dataset_result_count": len(selected),
+            "exact_source_profiles": sorted({row["runtime"] for row in selected}),
+            "timing_admitted": False,
+        }
+    return profile_summary, comparison_summary
+
+
+def build_candidate(args: argparse.Namespace) -> dict[str, Any]:
+    base, output = args.base.resolve(), args.output_dir.resolve()
+    base_files = verify_base(base, args.freeze_receipt)
+    if output.exists():
+        fail(f"refuse to replace v7 candidate directory: {output}")
+    portable_manifest = read_object(args.portable_manifest)
+    records_ref = portable_manifest.get("records") or {}
+    records_path = args.portable_records.resolve()
+    if (
+        portable_manifest.get("schema") != "compressionbenchmark-native328-portable-manifest-v1"
+        or portable_manifest.get("status") != "accepted_portable_export"
+        or int(portable_manifest.get("pair_count", -1)) != EXPECTED_UNIVERSE
+        or records_ref.get("sha256") != sha256(records_path)
+        or int(records_ref.get("row_count", -1)) != EXPECTED_UNIVERSE
+    ):
+        fail("portable Native328 manifest/records are not accepted and bound")
+    pairs = read_gzip_jsonl(records_path)
+    if len(pairs) != EXPECTED_UNIVERSE:
+        fail("portable Native328 record count is not 328")
+    identities = {(str(row["dataset_id"]), str(row["method"])) for row in pairs}
+    reconciliation = read_object(base / "native86-recovery-reconciliation.json")
+    unresolved = expected_unresolved(reconciliation)
+    if identities != unresolved or len(identities) != EXPECTED_UNIVERSE:
+        fail("portable pair identities do not equal exact v6 unresolved identities")
+    expected_identity_sha = canonical_sha(f"{dataset}\0{method}" for dataset, method in unresolved)
+    if portable_manifest.get("pair_identity_sha256") != expected_identity_sha:
+        fail("portable identity-set SHA mismatch")
+
+    output.mkdir(parents=True)
+    for name in base_files:
+        relative = safe_relative(name)
+        target = output / relative
+        target.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(base / relative, target)
+
+    acceptance_sha = str((portable_manifest.get("independent_acceptance") or {}).get("sha256"))
+    completion_rows = [row for pair in pairs for row in rows_for_pair(pair, acceptance_sha)]
+    if not completion_rows:
+        fail("accepted completion produced no numeric website rows")
+    if any(row.get("compression_time_ns") is not None or row.get("decompression_time_ns") is not None for row in completion_rows):
+        fail("non-admitted completion timing leaked into public fields")
+
+    data_path = output / "data.json"
+    data = read_object(data_path)
+    if any(str(row.get("family", "")).casefold() == "glza" for row in data["dataset_results"]):
+        fail("GLZA exists in frozen base")
+    data["dataset_results"].extend(completion_rows)
+    data["dataset_results"] = sorted(data["dataset_results"], key=lambda row: (
+        row["dataset"], row["scope"], row.get("comparison_profile", row["runtime"]),
+        row["runtime"], row["family"], row["algorithm_variant"],
+    ))
+    recompute(data)
+    update_methods(data, completion_rows)
+    profiles, comparisons = completion_profile_summaries(completion_rows, pairs)
+    all_profiles = dict(data["coverage"].get("native86_profiles") or {})
+    all_profiles.update(profiles)
+    all_comparisons = dict(data["coverage"].get("native86_comparison_profiles") or {})
+    all_comparisons.update(comparisons)
+    runtimes = sorted({str(row.get("comparison_profile", row["runtime"])) for row in data["dataset_results"]})
+    exact_profiles = sorted({str(row["runtime"]) for row in data["dataset_results"]})
+    data["benchmark"]["implementation_runtimes"] = runtimes
+    data["benchmark"]["exact_source_profiles"] = exact_profiles
+    labels = data["benchmark"].setdefault("runtime_labels", {})
+    hosts = data["benchmark"].setdefault("runtime_hosts", {})
+    for profile in comparisons:
+        action = "V3 accepted recovery" if "current-recovery-v3" in profile else "V4 row-support recovery"
+        labels[profile] = f"Native C++ · server 166 · {action}"
+        hosts[profile] = "166"
+    data["benchmark"]["publication_note"] = (
+        "The server-166 Native86 matrix has 13,940 terminal pairs: 11,164 main numeric pairs, "
+        "2,274 explicit N/A pairs, and 502 original problem identities. V9 plus independently "
+        "verified server-192 results repaired 174 unique identities. The separately accepted "
+        "Native328 completion repairs the exact remaining 328 identities, so all 502 original "
+        "problem identities now have accepted rate/byte replacements. Source campaign, host, "
+        "binary, adapter configuration and eligible support remain explicit. Completion timing "
+        "is diagnostic and unavailable to timing or composite rankings without separate exact "
+        "timing admission. GLZA remains retired."
+    )
+
+    coverage = data["coverage"]
+    coverage.update(
+        dataset_result_row_count=len(data["dataset_results"]),
+        configuration_aggregate_row_count=len(data["configuration_aggregates"]),
+        family_best_aggregate_row_count=len(data["family_best_aggregates"]),
+        method_family_count=len({row["family"] for row in data["dataset_results"]}),
+        method_configuration_count=len({row["algorithm_variant"] for row in data["dataset_results"]}),
+        runtime_configuration_count=len({(row.get("comparison_profile", row["runtime"]), row["algorithm_variant"]) for row in data["dataset_results"]}),
+        runtime_count=len(runtimes), runtimes=runtimes,
+        timing_column_observation_count=sum(int(row.get("timing_column_count", 0)) for row in data["dataset_results"]),
+        timing_column_mean_dataset_result_count=sum(row.get("timing_aggregation") == "column_mean" for row in data["dataset_results"]),
+        timing_dataset_aggregate_result_count=sum(row.get("timing_aggregation") == "dataset_aggregate" for row in data["dataset_results"]),
+        timing_unavailable_dataset_result_count=sum(row.get("timing_aggregation") == "unavailable" for row in data["dataset_results"]),
+        native86_accepted_completion_pair_count=EXPECTED_UNIVERSE,
+        native86_accepted_unique_repair_pair_count=502,
+        native86_unresolved_problem_pair_count=0,
+        native86_profiles=all_profiles,
+        native86_comparison_profiles=all_comparisons,
+    )
+    runs = data["source"].setdefault("measurement_runs", [])
+    runs.append({
+        "schema": "site-native86-accepted-completion-import-v3",
+        "integrated_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "execution_host": HOST166,
+        "accepted_completion_pair_count": EXPECTED_UNIVERSE,
+        "accepted_unique_repair_pair_count": 502,
+        "unresolved_problem_pair_count": 0,
+        "timing_policy": portable_manifest["timing_policy"],
+        "portable_manifest_sha256": sha256(args.portable_manifest),
+        "portable_records_sha256": sha256(records_path),
+        "independent_acceptance_sha256": acceptance_sha,
+        "profiles": profiles,
+        "comparison_profiles": comparisons,
+    })
+    data_path.write_text(
+        json.dumps(data, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+
+    portable_manifest_public = output / "native86-row-support-v4-portable-manifest.json"
+    portable_records_public = output / "native86-row-support-v4-portable-results.jsonl.gz"
+    shutil.copy2(args.portable_manifest, portable_manifest_public)
+    shutil.copy2(records_path, portable_records_public)
+
+    old_accepted = {
+        (str(row["dataset_id"]), str(row["method"]))
+        for row in reconciliation["accepted_pair_identities"]
+    }
+    all_accepted = old_accepted | unresolved
+    if len(all_accepted) != 502:
+        fail("v7 accepted repair union is not exactly 502")
+    reconciliation.update(
+        status="passed_all_original_problem_identities_have_accepted_rate_byte_replacements",
+        accepted_pair_identities=[
+            {"dataset_id": dataset, "method": method}
+            for dataset, method in sorted(all_accepted)
+        ],
+        completion_v7={
+            "accepted_pair_count": EXPECTED_UNIVERSE,
+            "portable_manifest": {"path": portable_manifest_public.name, "sha256": sha256(portable_manifest_public)},
+            "portable_records": {"path": portable_records_public.name, "sha256": sha256(portable_records_public)},
+            "independent_acceptance_sha256": acceptance_sha,
+            "timing_policy": portable_manifest["timing_policy"],
+        },
+    )
+    reconciliation["counts"].update(
+        accepted_unique_repair_pairs=502,
+        current_unresolved_pairs=0,
+        accepted_completion_pairs=EXPECTED_UNIVERSE,
+    )
+    reconciliation_path = output / "native86-recovery-reconciliation.json"
+    reconciliation_path.write_text(
+        json.dumps(reconciliation, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+    coverage_path = output / "native86-coverage.json"
+    coverage_receipt = read_object(coverage_path)
+    coverage_receipt.update(
+        accepted_unique_repair_pair_count=502,
+        unresolved_problem_pair_count=0,
+        accepted_completion_pair_count=EXPECTED_UNIVERSE,
+        profiles=all_profiles,
+        comparison_profiles=all_comparisons,
+        accepted_completion={
+            "portable_manifest": {"path": portable_manifest_public.name, "sha256": sha256(portable_manifest_public)},
+            "portable_records": {"path": portable_records_public.name, "sha256": sha256(portable_records_public)},
+            "independent_acceptance_sha256": acceptance_sha,
+            "timing_admitted": False,
+        },
+    )
+    coverage_path.write_text(
+        json.dumps(coverage_receipt, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+    manifest_path = output / "manifest.json"
+    manifest = read_object(manifest_path)
+    manifest["counts"] = coverage
+    manifest["native86_imports"] = all_profiles
+    terminal = manifest.setdefault("native86_terminal_coverage", {})
+    terminal.update(
+        accepted_unique_repair_pairs=502,
+        unresolved_problem_pairs=0,
+        accepted_completion={
+            "pair_count": EXPECTED_UNIVERSE,
+            "portable_manifest": {"path": portable_manifest_public.name, "sha256": sha256(portable_manifest_public)},
+            "portable_records": {"path": portable_records_public.name, "sha256": sha256(portable_records_public)},
+            "independent_acceptance_sha256": acceptance_sha,
+        },
+        recovery_reconciliation={
+            "path": reconciliation_path.name,
+            "sha256": sha256(reconciliation_path),
+            "accepted_unique_repair_pairs": 502,
+            "unresolved_problem_pairs": 0,
+        },
+    )
+    manifest["data_sha256"] = sha256(data_path)
+    manifest_path.write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+
+    ui_path = output / "ui-data.json"
+    ui = build_ui_payload(data, sha256(data_path))
+    ui_path.write_text(
+        json.dumps(ui, ensure_ascii=False, separators=(",", ":"), allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    builder_public = output / "build_accepted_completion_v7.py"
+    shutil.copy2(Path(__file__).resolve(), builder_public)
+    readme = output / "README.md"
+    with readme.open("a", encoding="utf-8") as handle:
+        handle.write(
+            "\n## Native86 accepted completion v7\n\n"
+            "The independently accepted 328-pair completion closes the 502 original Native86 problem "
+            "identities for rate/byte reporting. Completion timing remains diagnostic and is excluded "
+            "from timing and composite rankings. Host, campaign action, binary, adapter configuration "
+            "and exact eligible support are retained as separate comparison dimensions.\n"
+        )
+
+    # Re-hash manifest/data after all generated content is stable.
+    manifest = read_object(manifest_path)
+    manifest["data_sha256"] = sha256(data_path)
+    manifest_path.write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n",
+        encoding="utf-8",
+    )
+    integration = {
+        "schema": "compressionbenchmark-native86-accepted-completion-integration-v1",
+        "status": "passed_not_published",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "base_v6_freeze_receipt_sha256": sha256(args.freeze_receipt),
+        "portable_manifest_sha256": sha256(args.portable_manifest),
+        "portable_records_sha256": sha256(records_path),
+        "independent_acceptance_sha256": acceptance_sha,
+        "counts": {
+            "base_publish_files": EXPECTED_BASE_FILES,
+            "accepted_completion_pairs": EXPECTED_UNIVERSE,
+            "original_problem_pairs": 502,
+            "accepted_unique_repair_pairs": 502,
+            "unresolved_problem_pairs": 0,
+            "dataset_result_rows": len(data["dataset_results"]),
+            "completion_dataset_result_rows": len(completion_rows),
+        },
+        "boundaries": {
+            "execution_host": HOST166,
+            "campaign_actions": sorted({str(pair["action"]) for pair in pairs}),
+            "exact_source_profiles": sorted({row["runtime"] for row in completion_rows}),
+            "comparison_profiles": sorted({row["comparison_profile"] for row in completion_rows}),
+            "binary_sha256": sorted({row["binary_sha256"] for row in completion_rows}),
+            "adapter_identity": "configuration plus binary SHA prefix in algorithm_variant",
+            "support_identity": "exact sorted aggregate-id SHA-256",
+            "timing": "diagnostic only; all public timing fields null",
+        },
+        "files": {
+            "data.json": sha256(data_path),
+            "ui-data.json": sha256(ui_path),
+            "manifest.json": sha256(manifest_path),
+            "native86-coverage.json": sha256(coverage_path),
+            "native86-recovery-reconciliation.json": sha256(reconciliation_path),
+        },
+    }
+    integration_path = output / "NATIVE86_ACCEPTED_COMPLETION_V7.json"
+    integration_path.write_text(
+        json.dumps(integration, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    publish_names = sorted(set(base_files) | {
+        portable_manifest_public.name,
+        portable_records_public.name,
+        builder_public.name,
+        integration_path.name,
+    })
+    publish_files = {name: sha256(output / safe_relative(name)) for name in publish_names}
+    freeze = {
+        "schema": "compressionbenchmark-site-v7-freeze-receipt-v1",
+        "status": "passed_not_published",
+        "created_at": dt.datetime.now(dt.timezone.utc).isoformat(),
+        "base_v6_freeze_receipt_sha256": sha256(args.freeze_receipt),
+        "accepted_completion_integration": {
+            "path": integration_path.name,
+            "sha256": sha256(integration_path),
+        },
+        "publish_file_count": len(publish_files),
+        "publish_files": publish_files,
+    }
+    freeze_path = output / "qa" / "SITE_V7_FREEZE_RECEIPT.json"
+    freeze_path.parent.mkdir(parents=True)
+    freeze_path.write_text(
+        json.dumps(freeze, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+    return freeze
+
+
+def parser() -> argparse.ArgumentParser:
+    value = argparse.ArgumentParser(description=__doc__)
+    sub = value.add_subparsers(dest="command", required=True)
+    export = sub.add_parser("export", help="create a portable bundle beside accepted server artifacts")
+    export.add_argument("--acceptance", type=Path, required=True)
+    export.add_argument("--expected-acceptance-sha256", required=True)
+    export.add_argument("--v4-manifest", type=Path, required=True)
+    export.add_argument("--v6-reconciliation", type=Path, required=True)
+    export.add_argument("--path-map", action="append", default=[], metavar="OLD=NEW")
+    export.add_argument("--output-dir", type=Path, required=True)
+    build = sub.add_parser("build", help="build a new v7 candidate from v6 and a portable bundle")
+    build.add_argument("--base", type=Path, required=True)
+    build.add_argument("--freeze-receipt", type=Path, required=True)
+    build.add_argument("--portable-manifest", type=Path, required=True)
+    build.add_argument("--portable-records", type=Path, required=True)
+    build.add_argument("--output-dir", type=Path, required=True)
+    return value
+
+
+def main() -> int:
+    args = parser().parse_args()
+    result = export_portable(args) if args.command == "export" else build_candidate(args)
+    print(json.dumps({"status": result["status"], "schema": result["schema"]}, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

data.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:433a82416f865225818c96816934218cd6eb0a4b19cfc608cc5e0010b3c46eac
-size 130436188
+oid sha256:fd2b20a29b87e4703fcc6601ee3bea2f5eb62f7c145291373aded904430bba73
+size 132322373

manifest.json

@@ -1,9 +1,9 @@
 {
   "counts": {
     "catalog_dataset_count": 164,
-    "configuration_aggregate_row_count": 4925,
+    "configuration_aggregate_row_count": 4966,
     "dataset_count": 164,
-    "dataset_result_row_count": 90897,
+    "dataset_result_row_count": 91701,
     "excluded_datasets": [
       "Arade",
       "app_flow",
@@ -15,15 +15,25 @@
       "tiktok_trending_hashtags_music",
       "youtube_trending_2019_2020"
     ],
-    "family_best_aggregate_row_count": 1646,
+    "family_best_aggregate_row_count": 1687,
     "measured_dataset_count": 164,
-    "method_configuration_count": 401,
+    "method_configuration_count": 411,
     "method_family_count": 104,
     "missing_measurement_policy": "Missing report and dataset/scope/runtime/configuration combinations are omitted; the UI must display them as unavailable, never as zero.",
     "missing_source_report_count": 0,
+    "native86_accepted_completion_pair_count": 328,
     "native86_accepted_repair_overlap_pair_count": 1,
-    "native86_accepted_unique_repair_pair_count": 174,
+    "native86_accepted_unique_repair_pair_count": 502,
     "native86_comparison_profiles": {
+      "cpp-native166-current-recovery-v3-baseline86-fixed-profiles-20260919-v3": {
+        "dataset_result_count": 768,
+        "exact_source_profiles": [
+          "cpp-native166-current-recovery-v3-d528da93"
+        ],
+        "execution_host": "166.111.68.166",
+        "pair_count": 301,
+        "timing_admitted": false
+      },
       "cpp-native166-main-458a218f": {
         "dataset_result_count": 25443,
         "exact_source_profiles": [
@@ -33,6 +43,15 @@
         "pair_count": 11164,
         "timing_admitted": true
       },
+      "cpp-native166-row-support-v4-baseline86-fixed-profiles-20260919-v3": {
+        "dataset_result_count": 36,
+        "exact_source_profiles": [
+          "cpp-native166-row-support-v4-d528da93"
+        ],
+        "execution_host": "166.111.68.166",
+        "pair_count": 27,
+        "timing_admitted": false
+      },
       "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3": {
         "dataset_result_count": 383,
         "exact_source_profiles": [
@@ -94,6 +113,17 @@
     "native86_main_numeric_pair_count": 11164,
     "native86_main_problem_pair_count": 502,
     "native86_profiles": {
+      "cpp-native166-current-recovery-v3-d528da93": {
+        "aggregate_count": 10834,
+        "binary_sha256": "d528da93470af747b3ecf6cfd9a9b4c883f07caf74731f03e00320a8b583b8fb",
+        "comparison_profiles": [
+          "cpp-native166-current-recovery-v3-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 768,
+        "execution_host": "166.111.68.166",
+        "pair_count": 301,
+        "timing_profile_status": "timing_diagnostic_rate_bytes_accepted_without_separate_timing_admission"
+      },
       "cpp-native166-main-458a218f": {
         "aggregate_count": 290745,
         "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
@@ -171,6 +201,17 @@
         "pair_count": 40,
         "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
       },
+      "cpp-native166-row-support-v4-d528da93": {
+        "aggregate_count": 3653,
+        "binary_sha256": "d528da93470af747b3ecf6cfd9a9b4c883f07caf74731f03e00320a8b583b8fb",
+        "comparison_profiles": [
+          "cpp-native166-row-support-v4-baseline86-fixed-profiles-20260919-v3"
+        ],
+        "dataset_result_count": 36,
+        "execution_host": "166.111.68.166",
+        "pair_count": 27,
+        "timing_profile_status": "timing_diagnostic_rate_bytes_accepted_without_separate_timing_admission"
+      },
       "cpp-native192-first12-3452a998": {
         "aggregate_count": 493,
         "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
@@ -272,14 +313,16 @@
       }
     },
     "native86_terminal_pair_count": 13940,
-    "native86_unresolved_problem_pair_count": 328,
+    "native86_unresolved_problem_pair_count": 0,
     "native86_v9_recovered_pair_count": 154,
     "paper_leaderboard_row_count": 0,
-    "runtime_configuration_count": 1025,
-    "runtime_count": 9,
+    "runtime_configuration_count": 1041,
+    "runtime_count": 11,
     "runtimes": [
       "cpp",
+      "cpp-native166-current-recovery-v3-baseline86-fixed-profiles-20260919-v3",
       "cpp-native166-main-458a218f",
+      "cpp-native166-row-support-v4-baseline86-fixed-profiles-20260919-v3",
       "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3",
       "cpp-native192-first12-baseline86-fixed-profiles-20260919-v3",
       "cpp-native192-lzg-level5-fastfalse-lzg-level5-fast0-ngf1-empty-fixed-20261010-v2",
@@ -293,10 +336,10 @@
     "timing_column_mean_dataset_result_count": 25449,
     "timing_column_observation_count": 519087,
     "timing_dataset_aggregate_result_count": 0,
-    "timing_unavailable_dataset_result_count": 65448
+    "timing_unavailable_dataset_result_count": 66252
   },
   "data_file": "data.json",
-  "data_sha256": "433a82416f865225818c96816934218cd6eb0a4b19cfc608cc5e0010b3c46eac",
+  "data_sha256": "fd2b20a29b87e4703fcc6601ee3bea2f5eb62f7c145291373aded904430bba73",
   "dataset_catalog_sha256": "47869c8078e8c864810d4f961fa5879e120943bb3f371b39f0adc74f3de2ee2d",
   "excluded_content": [
     "raw datasets",
@@ -533,6 +576,17 @@
     }
   ],
   "native86_imports": {
+    "cpp-native166-current-recovery-v3-d528da93": {
+      "aggregate_count": 10834,
+      "binary_sha256": "d528da93470af747b3ecf6cfd9a9b4c883f07caf74731f03e00320a8b583b8fb",
+      "comparison_profiles": [
+        "cpp-native166-current-recovery-v3-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 768,
+      "execution_host": "166.111.68.166",
+      "pair_count": 301,
+      "timing_profile_status": "timing_diagnostic_rate_bytes_accepted_without_separate_timing_admission"
+    },
     "cpp-native166-main-458a218f": {
       "aggregate_count": 290745,
       "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
@@ -610,6 +664,17 @@
       "pair_count": 40,
       "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
     },
+    "cpp-native166-row-support-v4-d528da93": {
+      "aggregate_count": 3653,
+      "binary_sha256": "d528da93470af747b3ecf6cfd9a9b4c883f07caf74731f03e00320a8b583b8fb",
+      "comparison_profiles": [
+        "cpp-native166-row-support-v4-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 36,
+      "execution_host": "166.111.68.166",
+      "pair_count": 27,
+      "timing_profile_status": "timing_diagnostic_rate_bytes_accepted_without_separate_timing_admission"
+    },
     "cpp-native192-first12-3452a998": {
       "aggregate_count": 493,
       "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
@@ -711,6 +776,19 @@
     }
   },
   "native86_terminal_coverage": {
+    "accepted_completion": {
+      "independent_acceptance_sha256": "801b1f024ccf2adf08f5b948038c9c443f5e6de059190efb7c3a870c0c57ef77",
+      "pair_count": 328,
+      "portable_manifest": {
+        "path": "native86-row-support-v4-portable-manifest.json",
+        "sha256": "0f3334e929beceb683ada70b7df9f38ec6c007491525c586495de5e31c6f6cbe"
+      },
+      "portable_records": {
+        "path": "native86-row-support-v4-portable-results.jsonl.gz",
+        "sha256": "fc01b845db5a54b90555ec25dfb0c363bf1abea6bc2d1c8f025d5424df08a714"
+      }
+    },
+    "accepted_unique_repair_pairs": 502,
     "coverage_receipt": {
       "path": "native86-coverage.json",
       "sha256": "3ad4905aee17e3f4d9d74df2d547bf17a1d8473ec9aab52dbe9c8f11b144cf50"
@@ -754,13 +832,14 @@
     },
     "path": "native86-terminal-matrix.jsonl.gz",
     "recovery_reconciliation": {
-      "accepted_unique_repair_pairs": 174,
+      "accepted_unique_repair_pairs": 502,
       "path": "native86-recovery-reconciliation.json",
-      "sha256": "39f05a3195a1aeb3ad23114322b40fa91a205e5f798e1ceb7598beb91ae7c0f2",
-      "unresolved_problem_pairs": 328
+      "sha256": "617930f89371d33fa8b4428824f155391daba29051b5a97504aeaef510b37f01",
+      "unresolved_problem_pairs": 0
     },
     "rows": 13940,
     "sha256": "1f625d13e48d11c33c703517c13071d9ffc17ff98ed7b31e95277609251cccf9",
+    "unresolved_problem_pairs": 0,
     "v9_current154": {
       "pairs": 154,
       "path": "native86-v9-current154-thin.jsonl.gz",

native86-coverage.json

@@ -1,8 +1,30 @@
 {
+  "accepted_completion": {
+    "independent_acceptance_sha256": "801b1f024ccf2adf08f5b948038c9c443f5e6de059190efb7c3a870c0c57ef77",
+    "portable_manifest": {
+      "path": "native86-row-support-v4-portable-manifest.json",
+      "sha256": "0f3334e929beceb683ada70b7df9f38ec6c007491525c586495de5e31c6f6cbe"
+    },
+    "portable_records": {
+      "path": "native86-row-support-v4-portable-results.jsonl.gz",
+      "sha256": "fc01b845db5a54b90555ec25dfb0c363bf1abea6bc2d1c8f025d5424df08a714"
+    },
+    "timing_admitted": false
+  },
+  "accepted_completion_pair_count": 328,
   "accepted_repair_overlap_pair_count": 1,
-  "accepted_unique_repair_pair_count": 174,
+  "accepted_unique_repair_pair_count": 502,
   "active_method_count": 85,
   "comparison_profiles": {
+    "cpp-native166-current-recovery-v3-baseline86-fixed-profiles-20260919-v3": {
+      "dataset_result_count": 768,
+      "exact_source_profiles": [
+        "cpp-native166-current-recovery-v3-d528da93"
+      ],
+      "execution_host": "166.111.68.166",
+      "pair_count": 301,
+      "timing_admitted": false
+    },
     "cpp-native166-main-458a218f": {
       "dataset_result_count": 25443,
       "exact_source_profiles": [
@@ -12,6 +34,15 @@
       "pair_count": 11164,
       "timing_admitted": true
     },
+    "cpp-native166-row-support-v4-baseline86-fixed-profiles-20260919-v3": {
+      "dataset_result_count": 36,
+      "exact_source_profiles": [
+        "cpp-native166-row-support-v4-d528da93"
+      ],
+      "execution_host": "166.111.68.166",
+      "pair_count": 27,
+      "timing_admitted": false
+    },
     "cpp-native166-v9-recovery-baseline86-fixed-profiles-20260919-v3": {
       "dataset_result_count": 383,
       "exact_source_profiles": [
@@ -165,6 +196,17 @@
     "terminal_problem_failed": 71
   },
   "profiles": {
+    "cpp-native166-current-recovery-v3-d528da93": {
+      "aggregate_count": 10834,
+      "binary_sha256": "d528da93470af747b3ecf6cfd9a9b4c883f07caf74731f03e00320a8b583b8fb",
+      "comparison_profiles": [
+        "cpp-native166-current-recovery-v3-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 768,
+      "execution_host": "166.111.68.166",
+      "pair_count": 301,
+      "timing_profile_status": "timing_diagnostic_rate_bytes_accepted_without_separate_timing_admission"
+    },
     "cpp-native166-main-458a218f": {
       "aggregate_count": 290745,
       "binary_sha256": "458a218fd2e8668dbbac6b70f132db8ffe9de786718db4c28424b6e62b7d5664",
@@ -242,6 +284,17 @@
       "pair_count": 40,
       "timing_profile_status": "timing_diagnostic_recovery_campaign_binary_receipt_bound"
     },
+    "cpp-native166-row-support-v4-d528da93": {
+      "aggregate_count": 3653,
+      "binary_sha256": "d528da93470af747b3ecf6cfd9a9b4c883f07caf74731f03e00320a8b583b8fb",
+      "comparison_profiles": [
+        "cpp-native166-row-support-v4-baseline86-fixed-profiles-20260919-v3"
+      ],
+      "dataset_result_count": 36,
+      "execution_host": "166.111.68.166",
+      "pair_count": 27,
+      "timing_profile_status": "timing_diagnostic_rate_bytes_accepted_without_separate_timing_admission"
+    },
     "cpp-native192-first12-3452a998": {
       "aggregate_count": 493,
       "binary_sha256": "3452a998adb5d5aba2906397d43637ae06e2fbe9fa5bed34425c283c0a896c03",
@@ -345,7 +398,7 @@
   "schema": "site-native86-full-terminal-coverage-v2",
   "status": "passed",
   "terminal_pair_count": 13940,
-  "unresolved_problem_pair_count": 328,
+  "unresolved_problem_pair_count": 0,
   "v9_numeric_ok_aggregate_count": 5296,
   "v9_recovered_pair_count": 154
 }

native86-recovery-reconciliation.json

@@ -1,684 +1,1992 @@
 {
   "accepted_pair_identities": [
     {
-      "dataset_id": "ETDataset-ett",
-      "method": "LZJB"
+      "dataset_id": "Air-Quality",
+      "method": "CSC"
     },
     {
-      "dataset_id": "METR-LA",
-      "method": "LZJB"
+      "dataset_id": "Bar-Crawl",
+      "method": "CSC"
     },
     {
-      "dataset_id": "PEMS-BAY",
-      "method": "LZJB"
+      "dataset_id": "Bar-Crawl",
+      "method": "Camel"
     },
     {
-      "dataset_id": "PEMS-BAY",
-      "method": "Tornado"
+      "dataset_id": "Bar-Crawl",
+      "method": "LZO2A"
     },
     {
-      "dataset_id": "SpatialEpiBench",
+      "dataset_id": "Bar-Crawl",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "SpatialEpiBench",
-      "method": "Tornado"
+      "dataset_id": "Bird-migration",
+      "method": "CSC"
     },
     {
-      "dataset_id": "africa_senegal_mauritania_crops_spi",
-      "method": "Tornado"
+      "dataset_id": "Bird-migration",
+      "method": "LZJB"
     },
     {
-      "dataset_id": "ast_spacemobile_fleet_data",
-      "method": "Tornado"
+      "dataset_id": "Bird-migration",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "auto_production_sf",
-      "method": "Tornado"
+      "dataset_id": "Comments",
+      "method": "CSC"
     },
     {
-      "dataset_id": "bitcoin",
-      "method": "LZJB"
+      "dataset_id": "Comments",
+      "method": "Crush"
     },
     {
-      "dataset_id": "bitcoin_price_timeseries",
-      "method": "LZSSE"
+      "dataset_id": "Comments",
+      "method": "LZJB"
     },
     {
-      "dataset_id": "car_parts",
-      "method": "Tornado"
+      "dataset_id": "Comments",
+      "method": "LZSSE"
     },
     {
-      "dataset_id": "coastal_t_s",
-      "method": "CSC"
+      "dataset_id": "ETDataset-ett",
+      "method": "Gipfeli"
     },
     {
-      "dataset_id": "coastal_t_s",
+      "dataset_id": "ETDataset-ett",
       "method": "LZJB"
     },
     {
-      "dataset_id": "coastal_t_s",
-      "method": "Tornado"
+      "dataset_id": "ETDataset-ett",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "commodity_import",
-      "method": "Tornado"
+      "dataset_id": "IGlocations2",
+      "method": "CSC"
     },
     {
-      "dataset_id": "commodity_production",
+      "dataset_id": "IGlocations2",
       "method": "LZJB"
     },
     {
-      "dataset_id": "commodity_production",
+      "dataset_id": "IGlocations2",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "commodity_production",
-      "method": "Tornado"
+      "dataset_id": "IGlocations2",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "covid_deaths-monash",
-      "method": "Tornado"
+      "dataset_id": "METR-LA",
+      "method": "Gipfeli"
     },
     {
-      "dataset_id": "current_velocity",
+      "dataset_id": "METR-LA",
       "method": "LZJB"
     },
     {
-      "dataset_id": "current_velocity",
-      "method": "LZSSE"
+      "dataset_id": "METR-LA",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "current_velocity",
-      "method": "Tornado"
+      "dataset_id": "Metro-Traffic",
+      "method": "CSC"
     },
     {
-      "dataset_id": "dmi-aarhus-weather-data",
-      "method": "LZSSE"
+      "dataset_id": "Metro-Traffic",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "dmi-aarhus-weather-data",
-      "method": "Tornado"
+      "dataset_id": "NYC_Yellow_Taxi_Trip",
+      "method": "CSC"
     },
     {
-      "dataset_id": "eea_pm25_forecasting",
+      "dataset_id": "NYC_Yellow_Taxi_Trip",
       "method": "LZJB"
     },
     {
-      "dataset_id": "eea_pm25_forecasting",
+      "dataset_id": "NYC_Yellow_Taxi_Trip",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "eea_pm25_forecasting",
-      "method": "Lzlib"
-    },
-    {
-      "dataset_id": "epf_electricity_price",
-      "method": "LZJB"
+      "dataset_id": "PEMS-BAY",
+      "method": "CSC"
     },
     {
-      "dataset_id": "forex_factory_calendar",
-      "method": "Tornado"
+      "dataset_id": "PEMS-BAY",
+      "method": "Gipfeli"
     },
     {
-      "dataset_id": "freshretailnet_50k",
-      "method": "LZG"
+      "dataset_id": "PEMS-BAY",
+      "method": "LZJB"
     },
     {
-      "dataset_id": "freshretailnet_50k",
-      "method": "LZSSE"
+      "dataset_id": "PEMS-BAY",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "freshretailnet_50k",
+      "dataset_id": "PEMS-BAY",
       "method": "Tornado"
     },
     {
-      "dataset_id": "freshretailnet_lt",
-      "method": "LZG"
+      "dataset_id": "RealEstate1",
+      "method": "CSC"
     },
     {
-      "dataset_id": "freshretailnet_lt",
-      "method": "LZJB"
+      "dataset_id": "RealEstate1",
+      "method": "Crush"
     },
     {
-      "dataset_id": "freshretailnet_lt",
-      "method": "LZSSE"
+      "dataset_id": "RealEstate1",
+      "method": "LZJB"
     },
     {
-      "dataset_id": "freshretailnet_lt",
-      "method": "Tornado"
+      "dataset_id": "RealEstate2",
+      "method": "CSC"
     },
     {
-      "dataset_id": "fulus_lyd_rates_2025",
-      "method": "LZJB"
+      "dataset_id": "RealEstate2",
+      "method": "Crush"
     },
     {
-      "dataset_id": "github_top_projects",
-      "method": "LZSSE"
+      "dataset_id": "RealEstate2",
+      "method": "Density"
     },
     {
-      "dataset_id": "github_top_projects",
-      "method": "Tornado"
+      "dataset_id": "RealEstate2",
+      "method": "LZJB"
     },
     {
-      "dataset_id": "global_influenza",
+      "dataset_id": "RealEstate2",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "global_influenza",
-      "method": "Tornado"
-    },
-    {
-      "dataset_id": "global_price",
-      "method": "LZSSE"
+      "dataset_id": "Romance",
+      "method": "CSC"
     },
     {
-      "dataset_id": "global_price",
-      "method": "Tornado"
+      "dataset_id": "Romance",
+      "method": "Camel"
     },
     {
-      "dataset_id": "globalstar_fleet_data",
-      "method": "Tornado"
+      "dataset_id": "Romance",
+      "method": "Crush"
     },
     {
-      "dataset_id": "gluco_tsfm_benchmark",
-      "method": "LZSSE"
+      "dataset_id": "Romance",
+      "method": "LZJB"
     },
     {
-      "dataset_id": "gluco_tsfm_benchmark",
+      "dataset_id": "Romance",
       "method": "Tornado"
     },
     {
-      "dataset_id": "goes_omni_electron_flux_forecasting",
-      "method": "LZJB"
+      "dataset_id": "SpatialEpiBench",
+      "method": "Crush"
     },
     {
-      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "dataset_id": "SpatialEpiBench",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "goes_omni_electron_flux_forecasting",
-      "method": "Lzlib"
+      "dataset_id": "SpatialEpiBench",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "dataset_id": "SpatialEpiBench",
       "method": "Tornado"
     },
     {
-      "dataset_id": "hospital-monash",
-      "method": "Tornado"
+      "dataset_id": "Telco",
+      "method": "CSC"
     },
     {
-      "dataset_id": "hourly-stock-data-2023",
-      "method": "LZSSE"
+      "dataset_id": "Telco",
+      "method": "Camel"
     },
     {
-      "dataset_id": "hourly_electricity_demand_brazil",
-      "method": "LZSSE"
+      "dataset_id": "Telco",
+      "method": "Crush"
     },
     {
-      "dataset_id": "housing_inventory",
-      "method": "Tornado"
+      "dataset_id": "Telco",
+      "method": "LZJB"
     },
     {
-      "dataset_id": "indian_stock_hourly_2017_2021",
+      "dataset_id": "Telco",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "job_claims",
-      "method": "Tornado"
+      "dataset_id": "Telco",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "jolts",
-      "method": "Tornado"
+      "dataset_id": "TrainsUK2",
+      "method": "CSC"
     },
     {
-      "dataset_id": "jovian_lightning",
+      "dataset_id": "TrainsUK2",
       "method": "LZJB"
     },
     {
-      "dataset_id": "jovian_lightning",
+      "dataset_id": "TrainsUK2",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "jovian_lightning",
-      "method": "Tornado"
+      "dataset_id": "Uberlandia",
+      "method": "CSC"
     },
     {
-      "dataset_id": "kaggle_web_traffic",
-      "method": "LZSSE"
+      "dataset_id": "Uberlandia",
+      "method": "Camel"
     },
     {
-      "dataset_id": "kaggle_web_traffic",
-      "method": "Tornado"
+      "dataset_id": "Uberlandia",
+      "method": "Crush"
     },
     {
-      "dataset_id": "kaggle_web_traffic_weekly",
+      "dataset_id": "Uberlandia",
       "method": "LZJB"
     },
     {
-      "dataset_id": "kaggle_web_traffic_weekly",
+      "dataset_id": "Uberlandia",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "kaggle_web_traffic_weekly",
+      "dataset_id": "Uberlandia",
       "method": "Tornado"
     },
     {
-      "dataset_id": "kdd_cup_2018",
-      "method": "LZJB"
+      "dataset_id": "Wins",
+      "method": "CSC"
     },
     {
-      "dataset_id": "knowable",
+      "dataset_id": "Wins",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "Wins",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "Wins",
       "method": "LZJB"
     },
     {
-      "dataset_id": "knowable",
+      "dataset_id": "Wins",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "knowable",
-      "method": "Tornado"
+      "dataset_id": "Wins",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "kraken-trading-data",
-      "method": "Crush"
+      "dataset_id": "YaleLanguages",
+      "method": "CSC"
     },
     {
-      "dataset_id": "kraken-trading-data",
+      "dataset_id": "YaleLanguages",
       "method": "LZJB"
     },
     {
-      "dataset_id": "kraken-trading-data",
+      "dataset_id": "YaleLanguages",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "kraken-trading-data",
+      "dataset_id": "YaleLanguages",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "africa_senegal_mauritania_crops_spi",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "africa_senegal_mauritania_crops_spi",
       "method": "Tornado"
     },
     {
-      "dataset_id": "kuiper_fleet_data",
+      "dataset_id": "ast_spacemobile_fleet_data",
       "method": "Tornado"
     },
     {
-      "dataset_id": "london_smart_meters",
-      "method": "LZJB"
+      "dataset_id": "australia_solar",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "london_smart_meters",
+      "dataset_id": "australian_electricity_demand",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "auto_production_sf",
       "method": "Tornado"
     },
     {
-      "dataset_id": "m2oe2_timeseries",
+      "dataset_id": "azure2019_u",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "bitcoin",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "bitcoin",
       "method": "LZJB"
     },
     {
-      "dataset_id": "m2oe2_timeseries",
+      "dataset_id": "bitcoin",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "bitcoin_price_timeseries",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "bitcoin_price_timeseries",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "bitcoin_price_timeseries",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "macroecon",
+      "dataset_id": "bitcoin_price_timeseries",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "car_parts",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "car_parts",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "car_parts",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "coastal_t_s",
       "method": "CSC"
     },
     {
-      "dataset_id": "macroecon",
+      "dataset_id": "coastal_t_s",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "coastal_t_s",
       "method": "LZJB"
     },
     {
-      "dataset_id": "macroecon",
-      "method": "LZSSE"
+      "dataset_id": "coastal_t_s",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "macroecon",
+      "dataset_id": "coastal_t_s",
       "method": "Tornado"
     },
     {
-      "dataset_id": "magseven_ml_ready_high_frequency_anomaly",
+      "dataset_id": "commodity_import",
       "method": "Tornado"
     },
     {
-      "dataset_id": "national_illness",
+      "dataset_id": "commodity_production",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "commodity_production",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "commodity_production",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "niederschlag_station_4091_bavaria_germany",
+      "dataset_id": "commodity_production",
       "method": "Tornado"
     },
     {
-      "dataset_id": "nn5_weekly",
+      "dataset_id": "covid_deaths-monash",
       "method": "Tornado"
     },
     {
-      "dataset_id": "oikolab_weather",
-      "method": "LZJB"
+      "dataset_id": "crypto_data",
+      "method": "CSC"
     },
     {
-      "dataset_id": "oikolab_weather",
+      "dataset_id": "crypto_data",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "crypto_data",
+      "method": "Density"
+    },
+    {
+      "dataset_id": "crypto_data",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "oikolab_weather",
+      "dataset_id": "crypto_data",
       "method": "Tornado"
     },
     {
-      "dataset_id": "ooni_censorship_historical",
+      "dataset_id": "current_velocity",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "current_velocity",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "current_velocity",
       "method": "LZJB"
     },
     {
-      "dataset_id": "ooni_censorship_historical",
+      "dataset_id": "current_velocity",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "current_velocity",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "ooni_censorship_historical",
+      "dataset_id": "current_velocity",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "current_velocity",
       "method": "Tornado"
     },
     {
-      "dataset_id": "openelectricity_nem",
-      "method": "LZJB"
+      "dataset_id": "deep-space-probes",
+      "method": "CSC"
     },
     {
-      "dataset_id": "orbital_chaos_nasa_ssc",
+      "dataset_id": "deep-space-probes",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "deep-space-probes",
       "method": "LZJB"
     },
     {
-      "dataset_id": "orbital_chaos_nasa_ssc",
+      "dataset_id": "deep-space-probes",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "deep-space-probes",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "dmi-aarhus-weather-data",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "orbital_chaos_nasa_ssc",
+      "dataset_id": "dmi-aarhus-weather-data",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "dmi-aarhus-weather-data",
       "method": "Tornado"
     },
     {
-      "dataset_id": "pedestrian_counts",
-      "method": "LZJB"
+      "dataset_id": "dst-index",
+      "method": "CSC"
     },
     {
-      "dataset_id": "pedestrian_counts",
+      "dataset_id": "dst-index",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "ecdc_covid",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "ecdc_covid",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "ecdc_covid",
       "method": "Tornado"
     },
     {
-      "dataset_id": "phenology_normal_hawaii",
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "polymarket_crypto_5m_15m",
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "Lzlib"
+    },
+    {
+      "dataset_id": "eea_pm25_forecasting",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "electricity_demand",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "electricity_load_2011_2014",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "electricity_load_2011_2014",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "electricity_load_2011_2014",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "electricity_load_2011_2014",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "polymarket_crypto_5m_15m",
+      "dataset_id": "electricity_load_2011_2014",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "electricity_load_2011_2014",
       "method": "Tornado"
     },
     {
-      "dataset_id": "port_activity",
-      "method": "LZSSE"
+      "dataset_id": "electricity_production",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "enedis-with-holidays",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "enedis-with-holidays",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "enedis-with-holidays",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "epf_electricity_price",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "eweld_load",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "eweld_load",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "eweld_load",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "faang_engineered_time_series_features_2013_2025",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "forex_factory_calendar",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "forex_factory_calendar",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "forex_factory_calendar",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "fred_md",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "fred_md",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "fred_md",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "LZG"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "freshretailnet_50k",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "LZG"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "freshretailnet_lt",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "fulus_lyd_rates_2025",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "github_top_projects",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "github_top_projects",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "github_top_projects",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "global_influenza",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "global_influenza",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "global_influenza",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "global_price",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "global_price",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "globalstar_fleet_data",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "gluco_tsfm_benchmark",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "gluco_tsfm_benchmark",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "gluco_tsfm_benchmark",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "gluco_tsfm_benchmark",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Lzlib"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "goes_omni_electron_flux_forecasting",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "hospital-monash",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "hourly-stock-data-2023",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "hourly-stock-data-2023",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "hourly-stock-data-2023",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "hourly_electricity_demand_brazil",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "housing_inventory",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "indian_stock_hourly_2017_2021",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "indian_stock_hourly_2017_2021",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "indian_stock_hourly_2017_2021",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "job_claims",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "jolts",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "Density"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "jovian_lightning",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic_weekly",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic_weekly",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic_weekly",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic_weekly",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "kaggle_web_traffic_weekly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "kdd_cup_2018",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "kdd_cup_2018",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "kdd_cup_2018",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "kdd_cup_2018",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "knowable",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "kraken-trading-data",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "kuiper_fleet_data",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "london_smart_meters",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "london_smart_meters",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "london_smart_meters",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "london_smart_meters",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "london_smart_meters",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "Density"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "m2oe2_timeseries",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "macroecon",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "magseven_ml_ready_high_frequency_anomaly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "medium_posts",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "meteoblue",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "meteoblue",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "meteoblue",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "meteoblue",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "metropt_3",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "multi_model_trading_data",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "multi_model_trading_data",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "nasa_maven_kp_insitu",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "nasa_maven_kp_insitu",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "nasa_maven_kp_insitu",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "national_illness",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "ne_china_wind",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "niederschlag_station_4091_bavaria_germany",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "nifty50_market_regime",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "nn5_weekly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "oikolab_weather",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "ooni_censorship_historical",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "ooni_censorship_historical",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "ooni_censorship_historical",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "ooni_censorship_historical",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "ooni_censorship_historical",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "openelectricity_nem",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "openelectricity_nem",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "openelectricity_nem",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "orbital_chaos_nasa_ssc",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "pedestrian_counts",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "pedestrian_counts",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "pedestrian_counts",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "pedestrian_counts",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "phenology_normal_hawaii",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "polymarket_crypto_5m_15m",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "polymarket_crypto_5m_15m",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "polymarket_crypto_5m_15m",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "polymarket_crypto_5m_15m",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "port_activity",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "port_activity",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "port_activity",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "quitobench",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "quitobench",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "quitobench",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "quitobench",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "quitobench",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "rating",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "rating",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "rating",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "reg_forecasting_v2",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "reg_forecasting_v2",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "reg_forecasting_v2",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "rideshare",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "rideshare",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "rideshare",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "rideshare",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "rideshare",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "salesforecastingwomartstore",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "salesforecastingwomartstore",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "salesforecastingwomartstore",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "salesforecastingwomartstore",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "saugeenday-monash",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "saugeenday-monash",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "saugeenday-monash",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "scaphandre_cpu_usage",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "sg_carpark",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "sg_carpark",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "sg_carpark",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "sg_pm25",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "sg_pm25",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "sg_pm25",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "sg_weather",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "solar_10_minutes",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "solar_10_minutes",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "solar_10_minutes",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "solar_4_seconds",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "solar_4_seconds",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "solar_4_seconds",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "solar_4_seconds",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "solar_4_seconds",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "solar_weekly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "solusdt_enhanced_180",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "solusdt_enhanced_180",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "solusdt_enhanced_180",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "spx",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "stock_dataset",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "substorm_onsets",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "substorm_onsets",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "substorm_onsets",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "sunspot",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "sunspot",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "sunspot",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "sunspot",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "telangana_weather",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "telangana_weather",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "telangana_weather",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "telangana_weather",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "temperature_rain",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "temperature_rain",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "temperature_rain",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "temperature_rain",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "temperature_rain",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "timeseries-1m-QQQ-10y",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "timeseries-1m-QQQ-10y",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "timeseries-1m-QQQ-10y",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "timeseries-finance-ETF",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "timeseries-finance-ETF",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "timeseries-finance-ETF",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "timeseries-finance-ETF",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "timeseries-finance-ETF",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "timeseries_1mn_sp500",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "timeseries_1mn_sp500",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "timeseries_1mn_sp500",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "timeseries_1mn_stocks",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "timeseries_1mn_stocks",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "timeseries_1mn_stocks",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "timeseries_1mn_stocks",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "timeseries_1mn_stocks",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "timeseries_finance_etf_missing",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "timeseries_finance_etf_missing",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "timeseries_finance_etf_missing",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "timeseries_finance_etf_missing",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "timeseries_finance_etf_missing",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "tourism_monthly",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "tourism_monthly",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "tourism_monthly",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "tourism_monthly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "tourism_monthly-zaai-ai",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "tourism_monthly-zaai-ai",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "tourism_monthly-zaai-ai",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "tourism_monthly-zaai-ai",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "tourism_quarterly",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "tourism_quarterly",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "tourism_quarterly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "tourism_residuals",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "tourism_residuals",
+      "method": "Camel"
+    },
+    {
+      "dataset_id": "tourism_residuals",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "tourism_residuals",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "tourism_residuals",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "tourism_yearly",
+      "method": "Tornado"
+    },
+    {
+      "dataset_id": "traffic",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "traffic",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "traffic",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "traffic_hourly",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "traffic_hourly",
+      "method": "LZJB"
+    },
+    {
+      "dataset_id": "traffic_hourly",
+      "method": "LZSSE"
+    },
+    {
+      "dataset_id": "traffic_hourly",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "traffic_weekly",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "traffic_weekly",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "traffic_weekly",
+      "method": "Shrinker"
+    },
+    {
+      "dataset_id": "traffic_weekly",
+      "method": "Tornado"
     },
     {
-      "dataset_id": "port_activity",
+      "dataset_id": "traqq_weekly_activity",
       "method": "Tornado"
     },
     {
-      "dataset_id": "quitobench",
-      "method": "LZJB"
+      "dataset_id": "trending_stocks_yahoo_finance",
+      "method": "CSC"
     },
     {
-      "dataset_id": "quitobench",
+      "dataset_id": "trending_stocks_yahoo_finance",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "reg_forecasting_v2",
-      "method": "LZJB"
+      "dataset_id": "trending_stocks_yahoo_finance",
+      "method": "Tornado"
     },
     {
-      "dataset_id": "rideshare",
-      "method": "CSC"
+      "dataset_id": "trxusdt_spot_1m_05_2021_to_03_2026",
+      "method": "Gipfeli"
     },
     {
-      "dataset_id": "rideshare",
-      "method": "LZJB"
+      "dataset_id": "trxusdt_spot_1m_05_2021_to_03_2026",
+      "method": "LZO2A"
     },
     {
-      "dataset_id": "rideshare",
+      "dataset_id": "trxusdt_spot_1m_05_2021_to_03_2026",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "salesforecastingwomartstore",
-      "method": "Tornado"
-    },
-    {
-      "dataset_id": "saugeenday-monash",
-      "method": "LZJB"
+      "dataset_id": "trxusdt_spot_1m_05_2021_to_03_2026",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "scaphandre_cpu_usage",
-      "method": "Tornado"
+      "dataset_id": "uk_electricity_generation_mix_2019_2026",
+      "method": "CSC"
     },
     {
-      "dataset_id": "sg_carpark",
-      "method": "LZJB"
+      "dataset_id": "uk_electricity_generation_mix_2019_2026",
+      "method": "LZSSE"
     },
     {
-      "dataset_id": "sg_pm25",
-      "method": "LZJB"
+      "dataset_id": "uk_electricity_generation_mix_2019_2026",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "sg_weather",
-      "method": "LZJB"
+      "dataset_id": "us_births-monash",
+      "method": "CSC"
     },
     {
-      "dataset_id": "solar_10_minutes",
-      "method": "LZJB"
+      "dataset_id": "us_labor",
+      "method": "CSC"
     },
     {
-      "dataset_id": "solar_4_seconds",
+      "dataset_id": "us_labor",
       "method": "LZJB"
     },
     {
-      "dataset_id": "solar_4_seconds",
-      "method": "LZSSE"
+      "dataset_id": "us_labor",
+      "method": "Tornado"
     },
     {
-      "dataset_id": "solar_weekly",
-      "method": "Tornado"
+      "dataset_id": "us_stock_financial_ratios",
+      "method": "Bzip3"
     },
     {
-      "dataset_id": "solusdt_enhanced_180",
-      "method": "LZSSE"
+      "dataset_id": "us_stock_financial_ratios",
+      "method": "Camel"
     },
     {
-      "dataset_id": "stock_dataset",
-      "method": "LZJB"
+      "dataset_id": "us_stock_financial_ratios",
+      "method": "Tornado"
     },
     {
-      "dataset_id": "stock_dataset",
+      "dataset_id": "us_term_structure",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "substorm_onsets",
-      "method": "LZSSE"
+      "dataset_id": "vehicle_supply",
+      "method": "Tornado"
     },
     {
-      "dataset_id": "sunspot",
-      "method": "LZJB"
+      "dataset_id": "vehicle_trips",
+      "method": "Gipfeli"
     },
     {
-      "dataset_id": "telangana_weather",
-      "method": "LZJB"
+      "dataset_id": "vehicle_trips",
+      "method": "Tornado"
     },
     {
-      "dataset_id": "temperature_rain",
+      "dataset_id": "water_quality_darwin",
       "method": "LZJB"
     },
     {
-      "dataset_id": "temperature_rain",
+      "dataset_id": "water_quality_darwin",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "timeseries-1m-QQQ-10y",
-      "method": "LZSSE"
+      "dataset_id": "water_quality_darwin",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "timeseries-finance-ETF",
-      "method": "LZJB"
+      "dataset_id": "weather_data_NC",
+      "method": "CSC"
     },
     {
-      "dataset_id": "timeseries-finance-ETF",
-      "method": "LZSSE"
+      "dataset_id": "weather_data_NC",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "timeseries-finance-ETF",
+      "dataset_id": "weather_data_NC",
       "method": "Tornado"
     },
     {
-      "dataset_id": "timeseries_1mn_sp500",
-      "method": "Tornado"
+      "dataset_id": "weather_data_bavaria",
+      "method": "CSC"
     },
     {
-      "dataset_id": "timeseries_1mn_stocks",
-      "method": "Tornado"
+      "dataset_id": "weather_data_bavaria",
+      "method": "Crush"
     },
     {
-      "dataset_id": "timeseries_finance_etf_missing",
+      "dataset_id": "weather_data_bavaria",
+      "method": "LZG"
+    },
+    {
+      "dataset_id": "weather_data_bavaria",
       "method": "LZJB"
     },
     {
-      "dataset_id": "timeseries_finance_etf_missing",
+      "dataset_id": "weather_data_bavaria",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "timeseries_finance_etf_missing",
-      "method": "Tornado"
+      "dataset_id": "weather_data_bavaria",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "tourism_monthly",
-      "method": "LZJB"
+      "dataset_id": "weather_data_bavaria",
+      "method": "Tornado"
     },
     {
-      "dataset_id": "tourism_monthly",
-      "method": "LZSSE"
+      "dataset_id": "wids2023_competition_weather_forecasting",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "tourism_monthly",
+      "dataset_id": "wids2023_competition_weather_forecasting",
       "method": "Tornado"
     },
     {
-      "dataset_id": "tourism_monthly-zaai-ai",
-      "method": "LZSSE"
+      "dataset_id": "wind_4_seconds",
+      "method": "CSC"
     },
     {
-      "dataset_id": "tourism_quarterly",
-      "method": "LZSSE"
+      "dataset_id": "wind_4_seconds",
+      "method": "Gipfeli"
     },
     {
-      "dataset_id": "tourism_quarterly",
-      "method": "Tornado"
+      "dataset_id": "wind_4_seconds",
+      "method": "LZJB"
     },
     {
-      "dataset_id": "tourism_residuals",
+      "dataset_id": "wind_4_seconds",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "tourism_residuals",
-      "method": "Tornado"
+      "dataset_id": "wind_4_seconds",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "tourism_yearly",
-      "method": "Tornado"
+      "dataset_id": "wind_farms_minutely",
+      "method": "CSC"
     },
     {
-      "dataset_id": "traffic",
-      "method": "LZSSE"
+      "dataset_id": "wind_farms_minutely",
+      "method": "Crush"
     },
     {
-      "dataset_id": "traffic_hourly",
+      "dataset_id": "wind_farms_minutely",
+      "method": "Gipfeli"
+    },
+    {
+      "dataset_id": "wind_farms_minutely",
       "method": "LZJB"
     },
     {
-      "dataset_id": "traffic_hourly",
+      "dataset_id": "wind_farms_minutely",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "traffic_weekly",
-      "method": "CSC"
+      "dataset_id": "wind_farms_minutely",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "traffic_weekly",
-      "method": "Tornado"
+      "dataset_id": "wordle_mcm_dataset",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "traqq_weekly_activity",
-      "method": "Tornado"
+      "dataset_id": "wui_global",
+      "method": "CSC"
     },
     {
-      "dataset_id": "trending_stocks_yahoo_finance",
-      "method": "LZSSE"
+      "dataset_id": "wui_global",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "trending_stocks_yahoo_finance",
+      "dataset_id": "wui_global",
       "method": "Tornado"
     },
     {
-      "dataset_id": "trxusdt_spot_1m_05_2021_to_03_2026",
-      "method": "LZSSE"
+      "dataset_id": "xauusd",
+      "method": "Crush"
     },
     {
-      "dataset_id": "uk_electricity_generation_mix_2019_2026",
-      "method": "LZSSE"
+      "dataset_id": "xauusd",
+      "method": "Gipfeli"
     },
     {
-      "dataset_id": "us_labor",
+      "dataset_id": "xauusd",
       "method": "LZJB"
     },
     {
-      "dataset_id": "us_labor",
-      "method": "Tornado"
+      "dataset_id": "xauusd",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "us_stock_financial_ratios",
-      "method": "Bzip3"
+      "dataset_id": "xauusd_1m",
+      "method": "CSC"
     },
     {
-      "dataset_id": "us_stock_financial_ratios",
-      "method": "Tornado"
+      "dataset_id": "xauusd_1m",
+      "method": "LZSSE"
     },
     {
-      "dataset_id": "us_term_structure",
-      "method": "LZSSE"
+      "dataset_id": "xinyi_public_gym",
+      "method": "LZJB"
     },
     {
-      "dataset_id": "vehicle_supply",
-      "method": "Tornado"
+      "dataset_id": "xinyi_public_gym",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "vehicle_trips",
-      "method": "Tornado"
+      "dataset_id": "xrpusdt_spot_1m_05_2021_to_03_2026",
+      "method": "Gipfeli"
     },
     {
-      "dataset_id": "water_quality_darwin",
+      "dataset_id": "xrpusdt_spot_1m_05_2021_to_03_2026",
       "method": "LZJB"
     },
     {
-      "dataset_id": "water_quality_darwin",
+      "dataset_id": "xrpusdt_spot_1m_05_2021_to_03_2026",
+      "method": "LZO2A"
+    },
+    {
+      "dataset_id": "xrpusdt_spot_1m_05_2021_to_03_2026",
       "method": "LZSSE"
     },
     {
-      "dataset_id": "weather_data_NC",
-      "method": "Tornado"
+      "dataset_id": "xrpusdt_spot_1m_05_2021_to_03_2026",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "weather_data_bavaria",
-      "method": "LZG"
+      "dataset_id": "yongchun_public_gym",
+      "method": "Gipfeli"
     },
     {
-      "dataset_id": "weather_data_bavaria",
+      "dataset_id": "yongchun_public_gym",
       "method": "LZJB"
     },
     {
-      "dataset_id": "weather_data_bavaria",
-      "method": "LZSSE"
+      "dataset_id": "yongchun_public_gym",
+      "method": "Shrinker"
     },
     {
-      "dataset_id": "weather_data_bavaria",
-      "method": "Tornado"
+      "dataset_id": "zillow_viewer",
+      "method": "CSC"
+    },
+    {
+      "dataset_id": "zillow_viewer",
+      "method": "Crush"
+    },
+    {
+      "dataset_id": "zillow_viewer",
+      "method": "Gipfeli"
     },
     {
       "dataset_id": "zillow_viewer",
@@ -692,6 +2000,10 @@
       "dataset_id": "zillow_viewer",
       "method": "LZSSE"
     },
+    {
+      "dataset_id": "zillow_viewer",
+      "method": "Shrinker"
+    },
     {
       "dataset_id": "zillow_viewer",
       "method": "Tornado"
@@ -704,11 +2016,25 @@
     "v9_rate_and_bytes": "receipt/result/cold SHA-bound; all 154 have at least one numeric ok aggregate",
     "v9_timing": "diagnostic per variant until independent source/build/timing-boundary proof"
   },
+  "completion_v7": {
+    "accepted_pair_count": 328,
+    "independent_acceptance_sha256": "801b1f024ccf2adf08f5b948038c9c443f5e6de059190efb7c3a870c0c57ef77",
+    "portable_manifest": {
+      "path": "native86-row-support-v4-portable-manifest.json",
+      "sha256": "0f3334e929beceb683ada70b7df9f38ec6c007491525c586495de5e31c6f6cbe"
+    },
+    "portable_records": {
+      "path": "native86-row-support-v4-portable-results.jsonl.gz",
+      "sha256": "fc01b845db5a54b90555ec25dfb0c363bf1abea6bc2d1c8f025d5424df08a714"
+    },
+    "timing_policy": "diagnostic_only_public_ranking_fields_null_until_separate_exact_timing_admission"
+  },
   "counts": {
-    "accepted_unique_repair_pairs": 174,
+    "accepted_completion_pairs": 328,
+    "accepted_unique_repair_pairs": 502,
     "current327_backfill_pairs": 327,
     "current_numeric_pairs_after_accepted_overlay": 11338,
-    "current_unresolved_pairs": 328,
+    "current_unresolved_pairs": 0,
     "host192_strict_pairs": 21,
     "matrix_pairs": 13940,
     "omitted_unresolved_pairs": 1,
@@ -2134,7 +3460,7 @@
     }
   },
   "source_receipt_sha256": "e3660b8dd40a3f124d54c53e4814ee20d91a711c1ea323b53bb6675d81612498",
-  "status": "passed_with_one_omitted_problem_scheduled_for_separate_sidecar",
+  "status": "passed_all_original_problem_identities_have_accepted_rate_byte_replacements",
   "v9_new_since_stale_inventory": [
     {
       "all_aggregate_ids_sha256": "d497478804b3b649930470bdc28af6753e768d8e6ef12ff9380ef641ca8bf4d7",

native86-row-support-v4-portable-manifest.json

@@ -0,0 +1,34 @@
+{
+  "action_counts": {
+    "rerun_v4": 27,
+    "reuse_v3_recovered": 301
+  },
+  "aggregate_status_counts": {
+    "N/A": 277,
+    "ok": 13949,
+    "unsupported": 261
+  },
+  "created_at": "2026-10-11T13:26:56.998093+00:00",
+  "independent_acceptance": {
+    "accepted_universe_count": 328,
+    "schema": "paper164-native86-row-support-independent-acceptance-v4",
+    "sha256": "801b1f024ccf2adf08f5b948038c9c443f5e6de059190efb7c3a870c0c57ef77",
+    "status": "accepted"
+  },
+  "pair_count": 328,
+  "pair_identity_sha256": "999688c666f4e24e8ca9f3d5021b1dd941622fc5de95daff4f8cb033e310a687",
+  "records": {
+    "path": "native86-row-support-v4-portable-results.jsonl.gz",
+    "row_count": 328,
+    "sha256": "fc01b845db5a54b90555ec25dfb0c363bf1abea6bc2d1c8f025d5424df08a714"
+  },
+  "schema": "compressionbenchmark-native328-portable-manifest-v1",
+  "status": "accepted_portable_export",
+  "timing_policy": "diagnostic_only_public_ranking_fields_null_until_separate_exact_timing_admission",
+  "v4_manifest": {
+    "profile_version": "baseline86-fixed-profiles-20260919-v3",
+    "schema": "paper164-native86-row-support-sidecar-manifest-v4",
+    "sha256": "08a9fcdad1285bb0748b23e68c45475b8c6f9c5e59b2abf0d1f6697880a877a6"
+  },
+  "v6_reconciliation_sha256": "39f05a3195a1aeb3ad23114322b40fa91a205e5f798e1ceb7598beb91ae7c0f2"
+}

native86-row-support-v4-portable-results.jsonl.gz

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