Add verified single-record download guidance (#24)

- Add verified single-record download guidance (d584b1ba880bd92dfc4390256f76eddd9a3c6fb9)
- Normalize README line endings (09b176b394038b828b4ab62108ad748d1bc8508c)

LICENSE

@@ -0,0 +1,20 @@
+Time-Lapse Artifacts
+Copyright (c) 2026 Tim Maxwell
+
+Except where otherwise noted, this dataset is licensed under the Creative
+Commons Attribution-NonCommercial 4.0 International license (CC BY-NC 4.0):
+
+https://creativecommons.org/licenses/by-nc/4.0/
+
+Legal code:
+
+https://creativecommons.org/licenses/by-nc/4.0/legalcode
+
+The license applies only to material for which the licensor holds the
+necessary rights. It does not independently grant rights in incidental
+third-party content that may appear on screens, in references, or in captured
+audio. Users remain responsible for reviewing those rights and the terms of
+their downstream use.
+
+See README.md for the dataset's rights, privacy, audio, and attribution
+guidance.

README.md

@@ -609,6 +609,37 @@ intentional.
 
 Use `"pre_standard"` as the configuration name to stream the earlier tier.
 
+### Download and Verify One Record
+
+Install `huggingface_hub`, then use the included helper with a stable
+`record_id`:
+
+```bash
+python -m pip install huggingface_hub
+```
+
+The helper resolves the requested revision to an immutable commit, checks the
+indexed byte size and Xet identity against the pinned Hub headers, and reports
+the ordinary LFS-compatible SHA-256 separately.
+
+Check a record without downloading its video:
+
+```bash
+python tools/download_verified.py tla-a66bdad6c903b89f --check-only
+```
+
+Download that record and verify its local byte size and SHA-256:
+
+```bash
+python tools/download_verified.py tla-a66bdad6c903b89f \
+  --revision "<commit-or-tag>" \
+  --output-dir downloads
+```
+
+`hub_xet_hash` is an Xet file ID, not the SHA-256 of the downloaded bytes. The
+helper verifies both identities without conflating them. Video downloads may
+be many gigabytes; use `--check-only` first.
+
 For reproducible work:
 
 1. Pin a repository commit or release tag.
@@ -651,10 +682,14 @@ See `CHANGELOG.md` for release-level changes.
 
 - `metadata.csv` — canonical machine-readable index
 - `Pre_Standard_Time_Lapses/metadata.csv` — active pre-standard public index
+- `LICENSE` — CC BY-NC 4.0 notice and rights-scope qualification
 - `SCHEMA.md` — filename and metadata contracts
 - `Archive_Specifications.md` — acquisition specifications and known gaps
 - `VALIDATION.md` — validation scope and current results
+- `RELEASE_MANIFEST.json` — historical v0.2.0 release-candidate manifest; it
+  does not describe current `main` or provide checksums for the video payloads
 - `tools/capture_hub_inventory.py` — pinned Hub/Xet identity inventory
+- `tools/download_verified.py` — selected download and byte-integrity check
 - `tools/enrich_prestandard.py` — pinned Pre-Standard technical enrichment
 - `tools/validate_metadata.py` — cross-tier metadata and repository checks
 - `Standard_Time_Lapses/Provenance/` — historical evidence and mappings

tools/download_verified.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""Download one indexed video from a pinned Hub revision and verify its bytes.
+
+The script resolves a branch or tag to an immutable commit, checks the selected
+metadata row against the Hub's resolve headers, and optionally downloads the
+video. After download it verifies both the exact byte size and the ordinary
+LFS-compatible SHA-256. The Xet file ID is checked separately because it is not
+the SHA-256 of the downloaded file.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+from pathlib import Path
+from urllib.parse import quote
+
+from huggingface_hub import HfApi, hf_hub_download
+
+from capture_hub_inventory import read_identity
+
+
+DEFAULT_REPO_ID = "maxwellinked/time-lapse-artifacts"
+INDEX_PATHS = (
+    "metadata.csv",
+    "Pre_Standard_Time_Lapses/metadata.csv",
+)
+
+
+def load_record(repo_id: str, revision: str, record_id: str) -> dict[str, str]:
+    matches: list[dict[str, str]] = []
+    for index_path in INDEX_PATHS:
+        local_path = hf_hub_download(
+            repo_id=repo_id,
+            filename=index_path,
+            repo_type="dataset",
+            revision=revision,
+        )
+        with Path(local_path).open(encoding="utf-8", newline="") as handle:
+            for row in csv.DictReader(handle):
+                if row.get("record_id") == record_id:
+                    matches.append(row)
+
+    if not matches:
+        raise SystemExit(f"record_id not found: {record_id}")
+    if len(matches) != 1:
+        raise SystemExit(f"record_id is not unique across active indexes: {record_id}")
+    return matches[0]
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Download one indexed video and verify its pinned Hub identity."
+    )
+    parser.add_argument("record_id", help="Stable tla- record ID to download")
+    parser.add_argument(
+        "--repo-id",
+        default=DEFAULT_REPO_ID,
+        help=f"Dataset repository (default: {DEFAULT_REPO_ID})",
+    )
+    parser.add_argument(
+        "--revision",
+        default="main",
+        help="Branch, tag, or commit to resolve and pin (default: main)",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("downloads"),
+        help="Local download directory (default: downloads)",
+    )
+    parser.add_argument(
+        "--check-only",
+        action="store_true",
+        help="Verify metadata and Hub headers without downloading the video",
+    )
+    parser.add_argument("--timeout", type=int, default=30)
+    parser.add_argument("--retries", type=int, default=2)
+    args = parser.parse_args()
+
+    commit = HfApi().dataset_info(args.repo_id, revision=args.revision).sha
+    if not commit:
+        raise SystemExit(f"unable to resolve revision: {args.revision}")
+
+    row = load_record(args.repo_id, commit, args.record_id)
+    file_name = row.get("file_name", "")
+    expected_xet = row.get("hub_xet_hash", "").lower()
+    try:
+        expected_size = int(row.get("size_bytes", ""))
+    except ValueError as exc:
+        raise SystemExit(f"invalid size_bytes for {args.record_id}") from exc
+    if not file_name or not expected_xet:
+        raise SystemExit(f"incomplete identity metadata for {args.record_id}")
+
+    encoded_path = quote(file_name, safe="/")
+    resolve_url = (
+        f"https://huggingface.co/datasets/{args.repo_id}/"
+        f"resolve/{commit}/{encoded_path}"
+    )
+    identity = read_identity(resolve_url, args.timeout, args.retries)
+
+    if identity["repoCommit"] != commit:
+        raise SystemExit("resolve response came from a different repository revision")
+    if identity["xetHash"] != expected_xet:
+        raise SystemExit("Hub Xet identity differs from the indexed hub_xet_hash")
+    if identity["linkedSize"] != expected_size:
+        raise SystemExit("Hub byte size differs from the indexed size_bytes")
+
+    print(f"record_id: {args.record_id}")
+    print(f"revision: {commit}")
+    print(f"file: {file_name}")
+    print(f"size_bytes: {expected_size}")
+    print(f"hub_xet_hash: {expected_xet}")
+    print(f"sha256: {identity['linkedEtag']}")
+
+    if args.check_only:
+        print("verified metadata against pinned Hub headers; video not downloaded")
+        return
+
+    downloaded = Path(
+        hf_hub_download(
+            repo_id=args.repo_id,
+            filename=file_name,
+            repo_type="dataset",
+            revision=commit,
+            local_dir=args.output_dir,
+        )
+    )
+    actual_size = downloaded.stat().st_size
+    if actual_size != expected_size:
+        raise SystemExit(
+            f"downloaded size mismatch: expected {expected_size}, got {actual_size}"
+        )
+
+    actual_sha256 = sha256_file(downloaded)
+    if actual_sha256 != identity["linkedEtag"]:
+        raise SystemExit(
+            "downloaded SHA-256 differs from the pinned Hub LFS-compatible identity"
+        )
+
+    print(f"downloaded_to: {downloaded.resolve()}")
+    print("verified downloaded byte size and SHA-256")
+
+
+if __name__ == "__main__":
+    main()