Wave2 scrapers_and_normalizers overlay for US Code collectors/verifiers

scrapers_and_normalizers/ipfs_datasets_py/processors/legal_scrapers/country_laws_ir_scripts/normalize_country_laws.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""Normalize a country-law source into a CID-keyed corpus report (no GraphRAG, no upload)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+sys.path.insert(0, str(ROOT / "src"))
+
+from country_laws_ir.build import CACHE, REPORTS  # noqa: E402
+from country_laws_ir.catalog import get_country  # noqa: E402
+from country_laws_ir.normalize import build_corpus, load_source  # noqa: E402
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--source-repo", "--source", dest="source", default="endomorphosis/ipfs_malta_laws")
+    ap.add_argument("--out", default=None)
+    args = ap.parse_args()
+    country = get_country(args.source)
+    laws, articles, source_meta = load_source(country["repo"], CACHE)
+    corpus, report = build_corpus(laws, articles, source_meta)
+    out = Path(args.out) if args.out else REPORTS / f"{country['slug']}_normalization.json"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    print(json.dumps({
+        "out": str(out),
+        "n_out": int(len(corpus)),
+        "unit": report["unit"],
+        "drops": report["drops"],
+        "language_breakdown": report.get("language_breakdown"),
+        "quality_flags": report.get("quality_flags"),
+        "schema_surprises": report.get("schema_surprises"),
+    }, indent=2, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scrapers_and_normalizers/ipfs_datasets_py/processors/legal_scrapers/federal_scrapers/us_code_scraper.py

@@ -0,0 +1,2136 @@
+"""US Code scraper for building federal statutory law datasets.
+
+This module downloads and parses title packages from GovInfo package endpoints,
+producing section-level records suitable for full U.S. Code ingestion.
+
+Official sources (in order):
+1. GovInfo public content ZIP
+2. GovInfo package API ``zipLink`` (same method as Vaquill-AI/open-us-law)
+3. U.S. House OLRC releasepoint HTM ZIP
+
+Recovery-only fallbacks (not legal authority): Wayback CDX raw captures and,
+when enabled, Common Crawl. Archive.is is HTML-oriented and is not used for
+binary ZIP packages.
+"""
+
+import json
+import logging
+import os
+import re
+import time
+import zipfile
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, Iterator, List, Optional, Tuple
+from urllib.parse import urljoin
+from xml.etree import ElementTree as ET
+
+import anyio
+
+try:
+    import requests
+    from bs4 import BeautifulSoup
+
+    REQUESTS_AVAILABLE = True
+except ImportError:
+    REQUESTS_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_USCODE_CACHE_DIR = Path.home() / ".ipfs_datasets" / "us_code" / "cache"
+DEFAULT_USCODE_INDEX_DIR = Path.home() / ".ipfs_datasets" / "us_code"
+DEFAULT_USCODE_INDEX_PATH = DEFAULT_USCODE_INDEX_DIR / "uscode_index_latest.jsonl"
+DEFAULT_USCODE_JSONLD_DIRNAME = "uscode_jsonld"
+MIN_USCODE_YEAR = 1994
+USER_AGENT = "ipfs-datasets-uscode-scraper/2.0"
+DEFAULT_USCODE_DOWNLOAD_RETRIES = 4
+DEFAULT_USCODE_YEAR_FALLBACKS = 8
+DEFAULT_USHOUSE_RELEASE_MAX_PROBE = 220
+GOVINFO_API_BASE = "https://api.govinfo.gov"
+WAYBACK_CDX_URL = "https://web.archive.org/cdx/search/cdx"
+OFFICIAL_ZIP_SOURCES = (
+    "govinfo-content-zip",
+    "govinfo-api-ziplink",
+    "ushouse-releasepoint-htm-zip",
+)
+RECOVERY_ZIP_SOURCES = ("wayback-cdx", "common_crawl")
+SUBSEC_TOKEN_RE = re.compile(r"\(([0-9]+|[A-Za-z]{1,6})\)")
+ROMAN_LOWER_RE = re.compile(r"^[ivxlcdm]+$")
+ROMAN_UPPER_RE = re.compile(r"^[IVXLCDM]+$")
+COMMON_ROMAN_LOWER = {
+    "i",
+    "ii",
+    "iii",
+    "iv",
+    "v",
+    "vi",
+    "vii",
+    "viii",
+    "ix",
+    "x",
+    "xi",
+    "xii",
+    "xiii",
+    "xiv",
+    "xv",
+}
+COMMON_ROMAN_UPPER = {token.upper() for token in COMMON_ROMAN_LOWER}
+CHAPTER_RE = re.compile(
+    r"\b(CHAPTER\s+[A-Z0-9\-]+)\s*[\-—]\s*(.+?)(?=\s+Sec\.|\s+§|$)", re.IGNORECASE
+)
+SUBCHAPTER_RE = re.compile(
+    r"\b(SUBCHAPTER\s+[A-Z0-9\-]+)\s*[\-—]\s*(.+?)(?=\s+Sec\.|\s+§|$)", re.IGNORECASE
+)
+PART_RE = re.compile(r"\b(PART\s+[A-Z0-9\-]+)\s*[\-—]\s*(.+?)(?=\s+Sec\.|\s+§|$)", re.IGNORECASE)
+PUBLIC_LAW_CITATION_RE = re.compile(
+    r"Pub\.?\s*L\.?\s*(?:No\.?\s*)?\d+\s*[–—−‑-]\s*\d+", re.IGNORECASE
+)
+PUBLIC_LAW_LONGFORM_RE = re.compile(
+    r"Public\s+Law\s+(?:No\.?\s*)?\d+\s*[–—−‑-]\s*\d+", re.IGNORECASE
+)
+PUBLIC_LAW_CONGRESS_RE = re.compile(
+    r"Public\s+Law\s+\d+\s*,\s*[A-Za-z][A-Za-z\-\s]{1,80}\s+Congress", re.IGNORECASE
+)
+STAT_CITATION_RE = re.compile(r"\b\d+\s+Stat\.?\s+\d+\b", re.IGNORECASE)
+USC_CITATION_RE = re.compile(
+    r"\b\d+\s+U\.?\s*S\.?\s*C\.?\s*(?:§+\s*|sec(?:tion)?\.?\s*)?\d[\w\-\.()]*", re.IGNORECASE
+)
+TITLE_SECTION_CITATION_RE = re.compile(
+    r"\bsection\s+[\w\-.()]+\s+of\s+Title\s+\d+\b", re.IGNORECASE
+)
+THIS_TITLE_SECTION_CITATION_RE = re.compile(
+    r"\bsection\s+[\w\-.(),\sand]+\s+of\s+this\s+title\b", re.IGNORECASE
+)
+THIS_CHAPTER_SECTION_CITATION_RE = re.compile(
+    r"\bsection\s+[\w\-.(),\sand]+\s+of\s+this\s+chapter\b", re.IGNORECASE
+)
+ACT_CITATION_RE = re.compile(r"\bAct\s+[A-Z][a-z]{2,9}\.?\s+\d{1,2},\s+\d{4}\b", re.IGNORECASE)
+CHAPTER_STAT_CITATION_RE = re.compile(
+    r"\bch\.?\s*\d+[A-Za-z\-]*,\s*\d+\s+Stat\.?\s+\d+\b", re.IGNORECASE
+)
+DOCID_COMMENT_RE = re.compile(r"<!--\s*documentid:[^>]*-->", re.IGNORECASE)
+DOCID_SECTION_KEY_RE = re.compile(r"documentid:\s*[0-9A-Za-z]+_([0-9A-Za-z._\-]+)", re.IGNORECASE)
+USHOUSE_RELEASE_LINK_RE = re.compile(
+    r"releasepoints/us/pl/(?P<congress>\d+)/(?P<release>[A-Za-z0-9]+)/"
+    r"htm_usc(?P<title_code>[0-9]{2}[a-z]?)@(?P<tag>[0-9]+-[A-Za-z0-9]+)\\.zip",
+    re.IGNORECASE,
+)
+
+# US Code titles mapping
+US_CODE_TITLES = {
+    "1": "General Provisions",
+    "2": "The Congress",
+    "3": "The President",
+    "4": "Flag and Seal, Seat of Government, and the States",
+    "5": "Government Organization and Employees",
+    "6": "Domestic Security",
+    "7": "Agriculture",
+    "8": "Aliens and Nationality",
+    "9": "Arbitration",
+    "10": "Armed Forces",
+    "11": "Bankruptcy",
+    "12": "Banks and Banking",
+    "13": "Census",
+    "14": "Coast Guard",
+    "15": "Commerce and Trade",
+    "16": "Conservation",
+    "17": "Copyrights",
+    "18": "Crimes and Criminal Procedure",
+    "19": "Customs Duties",
+    "20": "Education",
+    "21": "Food and Drugs",
+    "22": "Foreign Relations and Intercourse",
+    "23": "Highways",
+    "24": "Hospitals and Asylums",
+    "25": "Indians",
+    "26": "Internal Revenue Code",
+    "27": "Intoxicating Liquors",
+    "28": "Judiciary and Judicial Procedure",
+    "29": "Labor",
+    "30": "Mineral Lands and Mining",
+    "31": "Money and Finance",
+    "32": "National Guard",
+    "33": "Navigation and Navigable Waters",
+    "34": "Crime Control and Law Enforcement",
+    "35": "Patents",
+    "36": "Patriotic and National Observances, Ceremonies, and Organizations",
+    "37": "Pay and Allowances of the Uniformed Services",
+    "38": "Veterans' Benefits",
+    "39": "Postal Service",
+    "40": "Public Buildings, Property, and Works",
+    "41": "Public Contracts",
+    "42": "The Public Health and Welfare",
+    "43": "Public Lands",
+    "44": "Public Printing and Documents",
+    "45": "Railroads",
+    "46": "Shipping",
+    "47": "Telecommunications",
+    "48": "Territories and Insular Possessions",
+    "49": "Transportation",
+    "50": "War and National Defense",
+    "51": "National and Commercial Space Programs",
+    "52": "Voting and Elections",
+    "54": "National Park Service and Related Programs",
+}
+
+_USHOUSE_DOWNLOAD_LINKS_BY_CODE: Optional[Dict[str, str]] = None
+_USHOUSE_RELEASE_CACHE_BY_CONGRESS: Dict[int, str] = {}
+
+
+def _title_sort_key(title: str) -> int:
+    try:
+        return int(str(title))
+    except Exception:
+        return 10**9
+
+
+def _normalize_titles(titles: Optional[List[str]]) -> List[str]:
+    if titles is None or "all" in [str(t).lower() for t in titles]:
+        return sorted(list(US_CODE_TITLES.keys()), key=_title_sort_key)
+    out: List[str] = []
+    for value in titles:
+        key = str(value).strip()
+        if key in US_CODE_TITLES:
+            out.append(key)
+    return sorted(list(dict.fromkeys(out)), key=_title_sort_key)
+
+
+def _make_session() -> "requests.Session":
+    session = requests.Session()
+    session.headers.update(
+        {
+            "User-Agent": USER_AGENT,
+            "Accept": "application/zip, text/html, application/xhtml+xml;q=0.9, */*;q=0.8",
+        }
+    )
+    return session
+
+
+def _govinfo_zip_url(year: int, title_num: str) -> str:
+    return (
+        f"https://www.govinfo.gov/content/pkg/USCODE-{int(year)}-title{title_num}/"
+        f"zip/USCODE-{int(year)}-title{title_num}.zip"
+    )
+
+
+def _govinfo_section_url(year: int, title_num: str, html_name: str) -> str:
+    return (
+        f"https://www.govinfo.gov/content/pkg/USCODE-{int(year)}-title{title_num}/html/{html_name}"
+    )
+
+
+def _govinfo_api_summary_url(year: int, title_num: str) -> str:
+    return f"{GOVINFO_API_BASE}/packages/USCODE-{int(year)}-title{title_num}/summary"
+
+
+def _govinfo_api_key() -> str:
+    return str(os.environ.get("GOVINFO_API_KEY") or "").strip()
+
+
+def _source_authority_class(source: str) -> str:
+    if source in OFFICIAL_ZIP_SOURCES:
+        return "official"
+    return "recovery"
+
+
+def _govinfo_api_zip_link(
+    session: "requests.Session",
+    *,
+    year: int,
+    title_num: str,
+) -> Optional[str]:
+    """Resolve the GovInfo package API zipLink used by Vaquill open-us-law."""
+
+    params: Dict[str, str] = {}
+    api_key = _govinfo_api_key()
+    if api_key:
+        params["api_key"] = api_key
+    try:
+        response = session.get(
+            _govinfo_api_summary_url(year, title_num),
+            params=params or None,
+            timeout=30,
+        )
+        if int(response.status_code) != 200:
+            return None
+        payload = response.json()
+    except Exception:
+        return None
+    if not isinstance(payload, dict):
+        return None
+    download = payload.get("download") if isinstance(payload.get("download"), dict) else {}
+    link = str(download.get("zipLink") or "").strip()
+    return link or None
+
+
+def _wayback_raw_capture_url(timestamp: str, original: str) -> str:
+    ts = str(timestamp or "").strip()
+    original_url = str(original or "").strip()
+    return f"https://web.archive.org/web/{ts}id_/{original_url}"
+
+
+def _wayback_cdx_zip_url(
+    session: "requests.Session",
+    original_url: str,
+) -> Optional[str]:
+    """Return a Wayback ``id_`` raw-capture URL for a GovInfo ZIP, if one exists."""
+
+    try:
+        response = session.get(
+            WAYBACK_CDX_URL,
+            params={
+                "url": original_url,
+                "output": "json",
+                "filter": "statuscode:200",
+                "fl": "timestamp,original,mimetype",
+                "limit": "8",
+            },
+            timeout=30,
+        )
+        if int(response.status_code) != 200:
+            return None
+        rows = response.json()
+    except Exception:
+        return None
+    if not isinstance(rows, list) or len(rows) < 2:
+        return None
+    header = [str(item).lower() for item in rows[0]]
+    try:
+        ts_idx = header.index("timestamp")
+        orig_idx = header.index("original")
+        mime_idx = header.index("mimetype") if "mimetype" in header else -1
+    except ValueError:
+        ts_idx, orig_idx, mime_idx = 0, 1, 2 if len(header) > 2 else -1
+    zip_hit: Optional[Tuple[str, str]] = None
+    any_hit: Optional[Tuple[str, str]] = None
+    for row in rows[1:]:
+        if not isinstance(row, list) or len(row) <= max(ts_idx, orig_idx):
+            continue
+        timestamp = str(row[ts_idx] or "").strip()
+        original = str(row[orig_idx] or original_url).strip()
+        if not timestamp or not original:
+            continue
+        mime = str(row[mime_idx] or "").lower() if mime_idx >= 0 and len(row) > mime_idx else ""
+        hit = (timestamp, original)
+        if "zip" in mime:
+            zip_hit = hit
+            break
+        if zip_hit is None and original.lower().endswith(".zip"):
+            zip_hit = hit
+        if any_hit is None:
+            any_hit = hit
+    chosen = zip_hit or any_hit
+    if chosen is None:
+        return None
+    return _wayback_raw_capture_url(chosen[0], chosen[1])
+
+
+def iter_official_title_zip_candidates(
+    session: "requests.Session",
+    *,
+    year: int,
+    title_num: str,
+) -> List[Dict[str, str]]:
+    """Official ZIP locations: public content URL, then GovInfo API zipLink."""
+
+    candidates: List[Dict[str, str]] = [
+        {
+            "source": "govinfo-content-zip",
+            "url": _govinfo_zip_url(year, title_num),
+            "authority": "official",
+        }
+    ]
+    api_link = _govinfo_api_zip_link(session, year=year, title_num=title_num)
+    if api_link and api_link != candidates[0]["url"]:
+        candidates.append(
+            {
+                "source": "govinfo-api-ziplink",
+                "url": api_link,
+                "authority": "official",
+            }
+        )
+    return candidates
+
+
+def iter_recovery_title_zip_candidates(
+    session: "requests.Session",
+    *,
+    year: int,
+    title_num: str,
+) -> List[Dict[str, str]]:
+    """Archive recovery candidates for a title ZIP. Not legal authority."""
+
+    original = _govinfo_zip_url(year, title_num)
+    candidates: List[Dict[str, str]] = []
+    wayback = _wayback_cdx_zip_url(session, original)
+    if wayback:
+        candidates.append(
+            {
+                "source": "wayback-cdx",
+                "url": wayback,
+                "authority": "recovery",
+            }
+        )
+    return candidates
+
+
+def build_uscode_section_url(title_num: str, section: str) -> str:
+    """Build the canonical U.S. Code section URL used by recovery fuzzing."""
+    title = str(title_num or "").strip()
+    normalized_section = str(section or "").strip()
+    if not title or not normalized_section:
+        return ""
+    return f"https://uscode.house.gov/view.xhtml?req=granuleid:USC-prelim-title{title}-section{normalized_section}"
+
+
+def build_public_law_url(congress: str, law_number: str) -> str:
+    """Build the Congress.gov public-law URL used by recovery fuzzing."""
+    normalized_congress = str(congress or "").strip()
+    normalized_law_number = str(law_number or "").strip()
+    if not normalized_congress or not normalized_law_number:
+        return ""
+    return f"https://www.congress.gov/public-law/{normalized_congress}th-congress/{normalized_law_number}"
+
+
+def _ushouse_download_page_url() -> str:
+    return "https://uscode.house.gov/download/download.shtml"
+
+
+def _ushouse_title_code(title_num: str) -> str:
+    value = str(title_num or "").strip()
+    if value.isdigit():
+        return f"{int(value):02d}"
+    return value.lower()
+
+
+def _year_to_congress(year: int) -> int:
+    # 1st Congress started in 1789 and each Congress spans two years.
+    return int((int(year) - 1789) // 2 + 1)
+
+
+def _looks_like_zip_response(response: "requests.Response") -> bool:
+    try:
+        content_type = str(response.headers.get("content-type") or "").lower()
+        if "zip" in content_type:
+            return True
+        magic = response.raw.read(4)
+        return magic == b"PK\x03\x04"
+    except Exception:
+        return False
+
+
+def _load_ushouse_download_links(session: "requests.Session") -> Dict[str, str]:
+    global _USHOUSE_DOWNLOAD_LINKS_BY_CODE
+    if _USHOUSE_DOWNLOAD_LINKS_BY_CODE is not None:
+        return dict(_USHOUSE_DOWNLOAD_LINKS_BY_CODE)
+
+    page_url = _ushouse_download_page_url()
+    response = session.get(page_url, timeout=40)
+    if int(response.status_code) != 200:
+        raise RuntimeError(f"Failed to load US House download page: HTTP {response.status_code}")
+
+    text = str(response.text or "")
+    matches = list(USHOUSE_RELEASE_LINK_RE.finditer(text))
+    if not matches:
+        raise RuntimeError("No US House releasepoint links found on download page")
+
+    links: Dict[str, str] = {}
+    for match in matches:
+        code = str(match.group("title_code") or "").lower()
+        rel = str(match.group(0) or "").strip()
+        if not code or not rel:
+            continue
+        if code not in links:
+            links[code] = urljoin("https://uscode.house.gov/download/", rel)
+
+    if not links:
+        raise RuntimeError("Unable to parse US House title links")
+
+    _USHOUSE_DOWNLOAD_LINKS_BY_CODE = dict(links)
+    return dict(links)
+
+
+def _discover_ushouse_release_for_congress(
+    session: "requests.Session",
+    congress: int,
+    *,
+    max_release_probe: int = DEFAULT_USHOUSE_RELEASE_MAX_PROBE,
+) -> Optional[str]:
+    congress_int = int(congress)
+    if congress_int in _USHOUSE_RELEASE_CACHE_BY_CONGRESS:
+        return _USHOUSE_RELEASE_CACHE_BY_CONGRESS[congress_int]
+
+    probe_code = "01"
+    for release in range(int(max_release_probe), 0, -1):
+        release_s = str(int(release))
+        url = (
+            f"https://uscode.house.gov/download/releasepoints/us/pl/{congress_int}/{release_s}/"
+            f"htm_usc{probe_code}@{congress_int}-{release_s}.zip"
+        )
+        try:
+            response = session.get(url, timeout=30, stream=True)
+            if int(response.status_code) != 200:
+                continue
+            if _looks_like_zip_response(response):
+                _USHOUSE_RELEASE_CACHE_BY_CONGRESS[congress_int] = release_s
+                return release_s
+        except Exception:
+            continue
+    return None
+
+
+def _ushouse_releasepoint_title_zip_url(*, congress: int, release: str, title_num: str) -> str:
+    code = _ushouse_title_code(title_num)
+    rel = str(release).strip()
+    return (
+        f"https://uscode.house.gov/download/releasepoints/us/pl/{int(congress)}/{rel}/"
+        f"htm_usc{code}@{int(congress)}-{rel}.zip"
+    )
+
+
+def _discover_latest_year(session: "requests.Session") -> Optional[int]:
+    current_year = datetime.now().year
+    for year in range(current_year, MIN_USCODE_YEAR - 1, -1):
+        probe = _govinfo_zip_url(year, "1")
+        try:
+            response = session.get(probe, timeout=25, stream=True)
+            if int(response.status_code) != 200:
+                continue
+            content_type = str(response.headers.get("content-type") or "").lower()
+            if "zip" not in content_type:
+                continue
+            chunk = response.raw.read(4)
+            if chunk == b"PK\x03\x04":
+                return year
+        except Exception:
+            continue
+    return None
+
+
+def _is_valid_zip_file(path: Path) -> bool:
+    if not path.exists() or path.stat().st_size <= 0:
+        return False
+    try:
+        with zipfile.ZipFile(path) as archive:
+            if archive.testzip() is not None:
+                return False
+        return True
+    except Exception:
+        return False
+
+
+def _download_title_zip(
+    session: "requests.Session",
+    *,
+    year: int,
+    title_num: str,
+    cache_dir: Path,
+    force_download: bool,
+    max_attempts: int = DEFAULT_USCODE_DOWNLOAD_RETRIES,
+    include_official: bool = True,
+    include_recovery: bool = False,
+) -> Dict[str, Any]:
+    out_path = cache_dir / f"USCODE-{int(year)}-title{title_num}.zip"
+    candidates: List[Dict[str, str]] = []
+    if include_official:
+        candidates.extend(
+            iter_official_title_zip_candidates(session, year=year, title_num=title_num)
+        )
+    if include_recovery:
+        candidates.extend(
+            iter_recovery_title_zip_candidates(session, year=year, title_num=title_num)
+        )
+    last_error: Optional[Exception] = None
+    attempts: List[Dict[str, Any]] = []
+    for candidate in candidates:
+        source = str(candidate.get("source") or "govinfo-content-zip")
+        url = str(candidate.get("url") or "")
+        try:
+            zip_path = _download_zip_from_url(
+                session,
+                url=url,
+                out_path=out_path,
+                force_download=force_download,
+                max_attempts=max_attempts,
+                not_found_hint=f"title {title_num} year {year} via {source}",
+            )
+            attempts.append({"source": source, "url": url, "status": "success"})
+            return {
+                "zip_path": zip_path,
+                "source": source,
+                "source_url": url,
+                "source_authority_class": _source_authority_class(source),
+                "attempts": attempts,
+            }
+        except Exception as exc:
+            last_error = exc if isinstance(exc, Exception) else Exception(str(exc))
+            attempts.append(
+                {
+                    "source": source,
+                    "url": url,
+                    "status": "error",
+                    "error": str(exc),
+                }
+            )
+            continue
+    if last_error is not None:
+        raise last_error
+    raise RuntimeError(f"Failed to download title zip for title {title_num} year {year}")
+
+
+def _download_zip_from_url(
+    session: "requests.Session",
+    *,
+    url: str,
+    out_path: Path,
+    force_download: bool,
+    max_attempts: int,
+    not_found_hint: str,
+) -> Path:
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    if out_path.exists() and not force_download:
+        if _is_valid_zip_file(out_path):
+            return out_path
+        try:
+            out_path.unlink(missing_ok=True)
+        except Exception:
+            pass
+
+    last_error: Optional[Exception] = None
+
+    for attempt in range(1, max(1, int(max_attempts)) + 1):
+        tmp_path = out_path.with_suffix(out_path.suffix + ".part")
+        try:
+            try:
+                tmp_path.unlink(missing_ok=True)
+            except Exception:
+                pass
+
+            response = session.get(url, timeout=90, stream=True)
+            status_code = int(response.status_code)
+            if status_code != 200:
+                if status_code == 404:
+                    raise RuntimeError(f"Title zip not found (HTTP 404) for {not_found_hint}")
+                raise RuntimeError(f"Failed to download title zip: HTTP {status_code} ({url})")
+
+            with tmp_path.open("wb") as handle:
+                for chunk in response.iter_content(chunk_size=1024 * 1024):
+                    if not chunk:
+                        continue
+                    handle.write(chunk)
+
+            if tmp_path.stat().st_size <= 0:
+                raise RuntimeError(f"Downloaded empty zip for {not_found_hint}")
+
+            if not _is_valid_zip_file(tmp_path):
+                raise RuntimeError(f"Downloaded invalid zip for {not_found_hint}")
+
+            tmp_path.replace(out_path)
+            return out_path
+        except Exception as exc:
+            last_error = exc if isinstance(exc, Exception) else Exception(str(exc))
+            try:
+                tmp_path.unlink(missing_ok=True)
+            except Exception:
+                pass
+
+            # 404 means this title-year package likely does not exist; fail fast for this year.
+            if "HTTP 404" in str(exc):
+                break
+
+            if attempt < max(1, int(max_attempts)):
+                time.sleep(min(8.0, float(attempt)))
+
+    if last_error is not None:
+        raise last_error
+    raise RuntimeError(f"Failed to download title zip for {not_found_hint}")
+
+
+def _download_title_zip_ushouse(
+    session: "requests.Session",
+    *,
+    title_num: str,
+    cache_dir: Path,
+    force_download: bool,
+    max_attempts: int = DEFAULT_USCODE_DOWNLOAD_RETRIES,
+    year: Optional[int] = None,
+) -> Dict[str, Any]:
+    cache_dir.mkdir(parents=True, exist_ok=True)
+
+    source_url: Optional[str] = None
+    source_release: Optional[str] = None
+    source_congress: Optional[int] = None
+
+    if year is not None:
+        congress = _year_to_congress(int(year))
+        release = _discover_ushouse_release_for_congress(session, congress)
+        if release:
+            source_congress = int(congress)
+            source_release = str(release)
+            source_url = _ushouse_releasepoint_title_zip_url(
+                congress=source_congress,
+                release=source_release,
+                title_num=title_num,
+            )
+
+    if not source_url:
+        links = _load_ushouse_download_links(session)
+        code = _ushouse_title_code(title_num).lower()
+        source_url = links.get(code)
+        if source_url:
+            match = USHOUSE_RELEASE_LINK_RE.search(source_url)
+            if match:
+                source_congress = int(match.group("congress"))
+                source_release = str(match.group("release"))
+
+    if not source_url:
+        raise RuntimeError(f"No US House releasepoint source URL found for title {title_num}")
+
+    year_part = str(int(year)) if year is not None else "latest"
+    out_name = f"USHOUSE-USCODE-{year_part}-title{title_num}"
+    if source_congress is not None and source_release is not None:
+        out_name += f"-c{source_congress}-r{source_release}"
+    out_path = cache_dir / f"{out_name}.zip"
+
+    zip_path = _download_zip_from_url(
+        session,
+        url=source_url,
+        out_path=out_path,
+        force_download=force_download,
+        max_attempts=max_attempts,
+        not_found_hint=f"US House releasepoint title {title_num}",
+    )
+
+    section_url_base = source_url.rsplit("/", 1)[0] if "/" in source_url else source_url
+    source_package = f"USHOUSE-USCODE-{source_congress or 'latest'}-{source_release or 'latest'}-title{title_num}"
+
+    return {
+        "zip_path": zip_path,
+        "source_url": source_url,
+        "source_package": source_package,
+        "section_url_base": section_url_base,
+        "source_congress": source_congress,
+        "source_release": source_release,
+    }
+
+
+def _candidate_years_for_title(
+    session: "requests.Session",
+    *,
+    title_num: str,
+    year: Optional[int],
+    max_year_fallbacks: int,
+) -> List[int]:
+    """Build candidate package years for a title, newest-first."""
+    if year is not None:
+        return [int(year)]
+
+    latest = _discover_latest_year(session)
+    if latest is None:
+        return []
+
+    window = max(1, int(max_year_fallbacks))
+    out: List[int] = []
+    for y in range(int(latest), MIN_USCODE_YEAR - 1, -1):
+        out.append(y)
+        if len(out) >= window:
+            break
+    return out
+
+
+def _extract_section_number_from_filename(file_name: str) -> str:
+    match = re.search(r"-sec([^.]+)\.htm$", file_name, flags=re.IGNORECASE)
+    if match:
+        return str(match.group(1)).strip()
+    return Path(file_name).stem
+
+
+def _extract_section_heading(text: str, section_number: str, fallback_heading: str) -> str:
+    source = _norm_space(str(text or ""))
+    sec_raw = str(section_number or "").strip()
+    sec_no = re.escape(sec_raw)
+    if not source or not sec_no:
+        return _norm_space(fallback_heading)[:500]
+
+    def _normalize_ref(value: str) -> str:
+        return re.sub(r"\s+", "", str(value or "").replace("–", "-").replace("—", "-").lower())
+
+    sec_norm = _normalize_ref(sec_raw)
+
+    sec_pattern = re.compile(
+        rf"Sec\.\s*{sec_no}\s*-\s*(.+?)(?=\s+From\s+the\s+U\.S\.\s+Government\s+Publishing\s+Office|\s+§\s*{sec_no}\.?|\s+Editorial\s+Notes|\s+Statutory\s+Notes|$)",
+        re.IGNORECASE,
+    )
+    sec_match = sec_pattern.search(source)
+    if sec_match:
+        return _norm_space(sec_match.group(1))[:500]
+
+    secs_pattern = re.compile(
+        r"Secs?\.\s*([^\-]{1,140})\s*-\s*(.+?)(?=\s+From\s+the\s+U\.S\.\s+Government\s+Publishing\s+Office|\s+§{1,2}\s|\s+Editorial\s+Notes|\s+Statutory\s+Notes|$)",
+        re.IGNORECASE,
+    )
+    for match in secs_pattern.finditer(source):
+        refs = _normalize_ref(match.group(1))
+        if sec_norm and sec_norm in refs:
+            return _norm_space(match.group(2))[:500]
+
+    section_symbol_pattern = re.compile(
+        rf"§\s*{sec_no}\.?\s*(.+?)(?=\s+\([a-zA-Z0-9]{{1,4}}\)\s|\s+\([A-Z][a-z]{{2,9}}\.?\s+\d{{1,2}},\s+\d{{4}}|\s+Editorial\s+Notes|\s+Statutory\s+Notes|$)",
+        re.IGNORECASE,
+    )
+    section_symbol_match = section_symbol_pattern.search(source)
+    if section_symbol_match:
+        return _norm_space(section_symbol_match.group(1))[:500]
+
+    section_symbols_pattern = re.compile(
+        r"§{2}\s*([^\.]{1,140})\.\s*(.+?)(?=\s+Editorial\s+Notes|\s+Statutory\s+Notes|$)",
+        re.IGNORECASE,
+    )
+    for match in section_symbols_pattern.finditer(source):
+        refs = _normalize_ref(match.group(1))
+        if sec_norm and sec_norm in refs:
+            return _norm_space(match.group(2))[:500]
+
+    return _norm_space(fallback_heading)[:500]
+
+
+_MODS_NS = {"mods": "http://www.loc.gov/mods/v3"}
+
+
+def parse_usc_mods_metadata(mods_xml: bytes) -> Dict[str, Dict[str, str]]:
+    """Parse GovInfo ``mods.xml`` granule metadata from a US Code title ZIP.
+
+    Adapted from the Vaquill-AI/open-us-law ``parse_usc_zip`` MODS walk
+    (Apache-2.0). Missing or malformed MODS is a no-op.
+    """
+
+    metadata: Dict[str, Dict[str, str]] = {}
+    if not mods_xml:
+        return metadata
+    try:
+        root = ET.fromstring(mods_xml)
+    except ET.ParseError:
+        return metadata
+    for item in root.iter("{http://www.loc.gov/mods/v3}relatedItem"):
+        rid = str(item.get("ID") or "")
+        if not rid.startswith("id-USCODE"):
+            continue
+        granule_id = rid[len("id-") :]
+        entry: Dict[str, str] = {}
+        title_info = item.find("mods:titleInfo", _MODS_NS)
+        if title_info is not None:
+            title_el = title_info.find("mods:title", _MODS_NS)
+            if title_el is not None and title_el.text:
+                entry["section_title"] = title_el.text.strip()
+            part = title_info.find("mods:partName", _MODS_NS)
+            if part is not None and part.text:
+                entry["part_name"] = part.text.strip()
+        for ident in item.findall("mods:identifier", _MODS_NS):
+            itype = str(ident.get("type") or "")
+            if itype == "Parent Id" and ident.text:
+                entry["parent_id"] = ident.text.strip()
+            elif itype == "uri" and ident.text:
+                entry["details_url"] = ident.text.strip()
+            elif itype == "former granule identifier" and ident.text:
+                entry["former_id"] = ident.text.strip()
+        for related in item.findall("mods:relatedItem", _MODS_NS):
+            href = str(related.get("{http://www.w3.org/1999/xlink}href") or "")
+            if ".htm" in href:
+                entry["html_url"] = href
+            elif ".pdf" in href:
+                entry["pdf_url"] = href
+        origin = item.find("mods:originInfo", _MODS_NS)
+        if origin is not None:
+            issued = origin.find("mods:dateIssued", _MODS_NS)
+            if issued is not None and issued.text:
+                entry["date_issued"] = issued.text.strip()
+        if entry:
+            metadata[granule_id] = entry
+    return metadata
+
+
+def _mods_from_zip(archive: zipfile.ZipFile) -> Dict[str, Dict[str, str]]:
+    for name in archive.namelist():
+        if name.lower().endswith("mods.xml"):
+            try:
+                return parse_usc_mods_metadata(archive.read(name))
+            except Exception:
+                return {}
+    return {}
+
+
+def _granule_id_from_html_name(html_name: str) -> str:
+    stem = Path(html_name).stem
+    return stem
+
+
+def _extract_section_number_and_heading(heading_text: str) -> tuple[str, str]:
+    text = _norm_space(heading_text)
+    if not text:
+        return "", ""
+
+    m = re.match(
+        r"^§+\s*([0-9A-Za-z.\-]+(?:\s+to\s+[0-9A-Za-z.\-]+)?)\.?\s*(.*)$", text, re.IGNORECASE
+    )
+    if m:
+        section_number = _norm_space(m.group(1)).strip()
+        heading = _norm_space(m.group(2)).strip(" .")
+        return section_number, heading or text
+
+    m = re.match(r"^(?:Sec\.|SEC\.)\s*([0-9A-Za-z.\-]+)\.?\s*(.*)$", text)
+    if m:
+        section_number = _norm_space(m.group(1)).strip()
+        heading = _norm_space(m.group(2)).strip(" .")
+        return section_number, heading or text
+
+    return "", text
+
+
+def _extract_sections_from_zip(
+    zip_path: Path,
+    *,
+    year: int,
+    title_num: str,
+    title_name: str,
+    include_metadata: bool,
+    source_package: Optional[str] = None,
+    section_url_base: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    def _iter_documentid_chunks(html_text: str) -> Iterator[str]:
+        markers = list(DOCID_COMMENT_RE.finditer(html_text))
+        for idx, marker in enumerate(markers):
+            start = marker.start()
+            end = markers[idx + 1].start() if idx + 1 < len(markers) else len(html_text)
+            if end > start:
+                yield html_text[start:end]
+
+    def _source_url_for_entry(html_name: str) -> str:
+        if section_url_base:
+            return f"{str(section_url_base).rstrip('/')}/{html_name}"
+        return _govinfo_section_url(year, title_num, html_name)
+
+    def _extract_consolidated_sections(html_text: str, html_name: str) -> List[Dict[str, Any]]:
+        consolidated: List[Dict[str, Any]] = []
+        for chunk in _iter_documentid_chunks(html_text):
+            if "section-head" not in chunk:
+                continue
+
+            soup = BeautifulSoup(chunk, "html.parser")
+            head = soup.find(class_=re.compile(r"\bsection-head\b", re.IGNORECASE))
+            if head is None:
+                continue
+
+            heading_text = _norm_space(head.get_text(" ", strip=True))
+            section_number, heading = _extract_section_number_and_heading(heading_text)
+            if not section_number:
+                match = DOCID_SECTION_KEY_RE.search(chunk)
+                if match:
+                    section_number = _norm_space(match.group(1)).strip("._-")
+            if not section_number:
+                continue
+
+            body_text = _norm_space(soup.get_text(" ", strip=True))
+            if not body_text:
+                continue
+
+            record: Dict[str, Any] = {
+                "section_number": section_number,
+                "heading": heading,
+                "text": body_text,
+                "body_text": body_text,
+                "citations": _extract_citations(body_text),
+            }
+            if include_metadata:
+                record.update(
+                    {
+                        "title_number": title_num,
+                        "title_name": title_name,
+                        "year": int(year),
+                        "package": source_package or f"USCODE-{int(year)}-title{title_num}",
+                        "source_url": _source_url_for_entry(html_name),
+                    }
+                )
+            consolidated.append(record)
+        return consolidated
+
+    def _apply_mods(record: Dict[str, Any], html_name: str) -> None:
+        granule_id = _granule_id_from_html_name(html_name)
+        meta = mods_meta.get(granule_id) or {}
+        if not meta:
+            return
+        record["granule_id"] = granule_id
+        if meta.get("section_title"):
+            record["heading"] = meta["section_title"][:500]
+        if meta.get("pdf_url"):
+            record["pdf_url"] = meta["pdf_url"]
+        if meta.get("details_url"):
+            record["details_url"] = meta["details_url"]
+        if meta.get("date_issued"):
+            record["date_issued"] = meta["date_issued"]
+        if meta.get("former_id"):
+            record["former_granule_id"] = meta["former_id"]
+        chapter = record.get("chapter")
+        if isinstance(chapter, dict) and meta.get("part_name") and not chapter.get("chapter_name"):
+            chapter["chapter_name"] = meta["part_name"]
+
+    sections: List[Dict[str, Any]] = []
+    with zipfile.ZipFile(zip_path) as archive:
+        mods_meta = _mods_from_zip(archive)
+        names = sorted(archive.namelist())
+        html_entries = [
+            name
+            for name in names
+            if name.lower().endswith((".htm", ".html")) and "-sec" in name.lower()
+        ]
+        if not html_entries:
+            html_entries = [name for name in names if name.lower().endswith((".htm", ".html"))]
+
+        for entry_name in html_entries:
+            html_name = Path(entry_name).name
+            raw = archive.read(entry_name)
+            try:
+                html_text = raw.decode("utf-8", errors="ignore")
+            except Exception:
+                html_text = str(raw)
+
+            if (
+                "documentid:" in html_text
+                and "section-head" in html_text
+                and "-sec" not in html_name.lower()
+            ):
+                for item in _extract_consolidated_sections(html_text, html_name):
+                    _apply_mods(item, html_name)
+                    sections.append(item)
+                continue
+
+            soup = BeautifulSoup(raw, "html.parser")
+
+            text = soup.get_text(" ", strip=True)
+            subsection_text = _trim_nonstatutory_tail(text)
+            section_number = _extract_section_number_from_filename(html_name)
+            heading_node = soup.find(["h1", "h2", "h3", "h4", "title"])
+            fallback_heading = heading_node.get_text(" ", strip=True) if heading_node else html_name
+            heading = _extract_section_heading(text, section_number, fallback_heading)
+            chapter_info = _extract_chapter_info(
+                subsection_text,
+                title_num=title_num,
+                title_name=title_name,
+                heading=heading,
+            )
+            section_body = _extract_section_body(subsection_text, section_number, heading)
+            preamble = _extract_preamble(section_body)
+            if not preamble:
+                preamble = _norm_space(heading)
+            citations = _extract_citations(text, subsection_text)
+            legislative_history = _extract_legislative_history(text, subsection_text)
+
+            record: Dict[str, Any] = {
+                "section_number": section_number,
+                "heading": heading[:500],
+                "text": text,
+                "chapter": chapter_info,
+                "preamble": preamble,
+                "citations": citations,
+                "legislative_history": legislative_history,
+                "subsections": _parse_subsections(section_body),
+            }
+            record["parser_warnings"] = _validate_subsection_tree(record.get("subsections") or [])
+            if include_metadata:
+                record.update(
+                    {
+                        "title_number": title_num,
+                        "title_name": title_name,
+                        "year": int(year),
+                        "package": source_package or f"USCODE-{int(year)}-title{title_num}",
+                        "source_url": _source_url_for_entry(html_name),
+                    }
+                )
+            _apply_mods(record, html_name)
+            sections.append(record)
+
+    return sections
+
+
+def _write_index_jsonl(sections: List[Dict[str, Any]], *, index_path: Path) -> None:
+    index_path.parent.mkdir(parents=True, exist_ok=True)
+    with index_path.open("w", encoding="utf-8") as handle:
+        for item in sections:
+            handle.write(json.dumps(item, ensure_ascii=False) + "\n")
+
+
+def _load_index_jsonl(index_path: Path) -> List[Dict[str, Any]]:
+    if not index_path.exists():
+        return []
+    out: List[Dict[str, Any]] = []
+    with index_path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except Exception:
+                continue
+            if isinstance(obj, dict):
+                out.append(obj)
+    return out
+
+
+def _norm_space(text: str) -> str:
+    text = str(text or "")
+    text = text.replace("\u00a0", " ")
+    text = text.replace("\ufeff", "")
+    text = text.replace("\u2019", "'")
+    text = text.replace("\u201c", '"').replace("\u201d", '"')
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+
+def _classify_subsec_kind(token: str, prev_kind: Optional[str]) -> str:
+    if token.isdigit():
+        return "numeric"
+
+    if token.islower():
+        if token in COMMON_ROMAN_LOWER and prev_kind in {
+            "alpha_upper",
+            "roman_lower",
+            "roman_upper",
+        }:
+            return "roman_lower"
+        if len(token) > 1 and ROMAN_LOWER_RE.match(token):
+            return "roman_lower"
+        return "alpha_lower"
+
+    if token.isupper():
+        if token in COMMON_ROMAN_UPPER and prev_kind in {"roman_lower", "roman_upper"}:
+            return "roman_upper"
+        if len(token) > 1 and ROMAN_UPPER_RE.match(token):
+            return "roman_upper"
+        return "alpha_upper"
+
+    return "other"
+
+
+def _subsec_level(kind: str) -> int:
+    order = {
+        "numeric": 1,
+        "alpha_lower": 2,
+        "alpha_upper": 3,
+        "roman_lower": 4,
+        "roman_upper": 5,
+        "other": 6,
+    }
+    return int(order.get(kind, 6))
+
+
+def _subsec_rank_map(first_kind: str) -> Dict[str, int]:
+    sequence = [
+        "numeric",
+        "alpha_lower",
+        "alpha_upper",
+        "roman_lower",
+        "roman_upper",
+        "other",
+    ]
+    if first_kind in sequence:
+        idx = sequence.index(first_kind)
+        sequence = sequence[idx:] + sequence[:idx]
+    return {kind: rank + 1 for rank, kind in enumerate(sequence)}
+
+
+def _find_subsec_markers(text: str) -> List[tuple[int, int, str]]:
+    markers: List[tuple[int, int, str]] = []
+    for match in SUBSEC_TOKEN_RE.finditer(text):
+        start = match.start()
+        end = match.end()
+        token = match.group(1)
+
+        if len(token) > 6:
+            continue
+        if token.isdigit() and len(token) > 3:
+            continue
+        if token.isalpha():
+            if not (token.islower() or token.isupper()):
+                continue
+            if len(token) > 1:
+                if token.islower() and not ROMAN_LOWER_RE.match(token):
+                    continue
+                if token.isupper() and not ROMAN_UPPER_RE.match(token):
+                    continue
+
+        prev_ch = text[start - 1] if start > 0 else ""
+        next_ch = text[end] if end < len(text) else ""
+
+        valid_left = (start == 0) or prev_ch.isspace() or prev_ch in ";:.(["
+        valid_right = (end == len(text)) or next_ch.isspace() or next_ch in "(),;:.]"
+        if not (valid_left and valid_right):
+            continue
+
+        markers.append((start, end, token))
+    return markers
+
+
+def _parse_subsections(text: str) -> List[Dict[str, Any]]:
+    text = _norm_space(text)
+    markers = _find_subsec_markers(text)
+    if not markers:
+        return []
+
+    items: List[Dict[str, Any]] = []
+    prev_kind: Optional[str] = None
+    for idx, (start, end, token) in enumerate(markers):
+        next_start = markers[idx + 1][0] if idx + 1 < len(markers) else len(text)
+        body = _norm_space(text[end:next_start])
+        kind = _classify_subsec_kind(token, prev_kind)
+        prev_kind = kind
+        items.append(
+            {
+                "start": start,
+                "end": end,
+                "label": f"({token})",
+                "token": token,
+                "kind": kind,
+                "text": body,
+                "subsections": [],
+            }
+        )
+
+    rank_map = _subsec_rank_map(str(items[0].get("kind") or "numeric"))
+    for item in items:
+        item["level"] = int(rank_map.get(str(item.get("kind") or "other"), _subsec_level("other")))
+
+    roots: List[Dict[str, Any]] = []
+    stack: List[Dict[str, Any]] = []
+    prev_item: Optional[Dict[str, Any]] = None
+    prev_node: Optional[Dict[str, Any]] = None
+
+    def _is_chained(current: Dict[str, Any], previous: Optional[Dict[str, Any]]) -> bool:
+        if previous is None:
+            return False
+        gap = text[int(previous["end"]) : int(current["start"])]
+        return gap.strip() == ""
+
+    for item in items:
+        level = int(item["level"])
+        chained = _is_chained(item, prev_item)
+
+        if chained and prev_node is not None:
+            parent_subsections = prev_node.get("subsections", [])
+        else:
+            while stack and int(stack[-1]["level"]) >= level:
+                stack.pop()
+            parent_subsections = roots if not stack else stack[-1]["subsections"]
+
+        existing_node: Optional[Dict[str, Any]] = None
+        for sibling in reversed(parent_subsections):
+            if sibling.get("label") == item["label"]:
+                existing_node = sibling
+                break
+
+        if existing_node is None:
+            node = {
+                "label": item["label"],
+                "token": item["token"],
+                "kind": item["kind"],
+                "text": item["text"],
+                "subsections": [],
+            }
+            parent_subsections.append(node)
+        else:
+            node = existing_node
+            new_text = item["text"]
+            old_text = _norm_space(str(node.get("text", "")))
+            if new_text:
+                if not old_text:
+                    node["text"] = new_text
+                elif new_text not in old_text:
+                    node["text"] = f"{old_text} {new_text}".strip()
+
+        if not chained:
+            stack.append({"level": level, "subsections": node["subsections"]})
+        prev_item = item
+        prev_node = node
+
+    return roots
+
+
+def _trim_nonstatutory_tail(text: str) -> str:
+    text = _norm_space(text)
+    if not text:
+        return text
+
+    cut_markers = [
+        "Editorial Notes",
+        "Statutory Notes and Related Subsidiaries",
+        "Amendments",
+        "References in Text",
+    ]
+
+    lower_text = text.lower()
+    cut_at: Optional[int] = None
+    for marker in cut_markers:
+        idx = lower_text.find(marker.lower())
+        if idx > 0:
+            cut_at = idx if cut_at is None else min(cut_at, idx)
+
+    if cut_at is None:
+        return text
+    return _norm_space(text[:cut_at])
+
+
+def _dedupe_keep_order(items: List[str]) -> List[str]:
+    out: List[str] = []
+    seen = set()
+    for item in items:
+        value = _norm_space(item)
+        if not value or value in seen:
+            continue
+        seen.add(value)
+        out.append(value)
+    return out
+
+
+def _extract_chapter_info(
+    text: str,
+    *,
+    title_num: str,
+    title_name: str,
+    heading: str,
+) -> Dict[str, Any]:
+    source = str(text or "")
+
+    for pattern in (CHAPTER_RE, SUBCHAPTER_RE, PART_RE):
+        match = pattern.search(source)
+        if match:
+            chapter_label = _norm_space(match.group(1)).upper()
+            chapter_name = _norm_space(match.group(2))
+            if chapter_name:
+                return {
+                    "chapter_label": chapter_label,
+                    "chapter_name": chapter_name,
+                    "chapter_inferred": False,
+                }
+
+    heading_text = _norm_space(heading)
+    heading_match = re.search(r"\b(CHAPTER\s+[A-Z0-9\-]+)\b", heading_text, flags=re.IGNORECASE)
+    if heading_match:
+        return {
+            "chapter_label": _norm_space(heading_match.group(1)).upper(),
+            "chapter_name": heading_text,
+            "chapter_inferred": True,
+        }
+
+    return {
+        "chapter_label": f"TITLE {str(title_num).strip()}",
+        "chapter_name": _norm_space(title_name),
+        "chapter_inferred": True,
+    }
+
+
+def _extract_section_body(text: str, section_number: str, heading: str) -> str:
+    core = _trim_nonstatutory_tail(text)
+    section_patterns = [
+        rf"§\s*{re.escape(section_number)}\.?\s*",
+        rf"Sec\.\s*{re.escape(section_number)}\s*-\s*",
+    ]
+
+    body = core
+    for pattern in section_patterns:
+        match = re.search(pattern, core, flags=re.IGNORECASE)
+        if match:
+            body = core[match.end() :]
+            break
+
+    heading_clean = _norm_space(heading)
+    if heading_clean and body.lower().startswith(heading_clean.lower()):
+        body = body[len(heading_clean) :].lstrip(" -:;,.\t")
+
+    return _norm_space(body)
+
+
+def _extract_preamble(section_body: str) -> str:
+    text = _norm_space(section_body)
+    if not text:
+        return ""
+
+    markers = _find_subsec_markers(text)
+    if markers and int(markers[0][0]) > 0:
+        return _norm_space(text[: int(markers[0][0])])
+
+    sentence_match = re.match(r"(.{1,500}?[\.;:])(\s|$)", text)
+    if sentence_match:
+        return _norm_space(sentence_match.group(1))
+    return _norm_space(text[:500])
+
+
+def _extract_citations(text: str, core_text: str = "") -> Dict[str, List[str]]:
+    base = str(text or "")
+    core = str(core_text or "") or base
+    public_laws = _dedupe_keep_order(
+        PUBLIC_LAW_CITATION_RE.findall(base)
+        + PUBLIC_LAW_LONGFORM_RE.findall(base)
+        + PUBLIC_LAW_CONGRESS_RE.findall(base)
+    )
+    statutes_at_large = _dedupe_keep_order(STAT_CITATION_RE.findall(base))
+    usc_citations = _dedupe_keep_order(
+        USC_CITATION_RE.findall(core)
+        + TITLE_SECTION_CITATION_RE.findall(core)
+        + THIS_TITLE_SECTION_CITATION_RE.findall(core)
+        + THIS_CHAPTER_SECTION_CITATION_RE.findall(core)
+    )
+    usc_citations = [
+        item
+        for item in usc_citations
+        if "united states code" not in item.lower() and "u.s.c. title" not in item.lower()
+    ]
+    session_laws = _dedupe_keep_order(
+        ACT_CITATION_RE.findall(base) + CHAPTER_STAT_CITATION_RE.findall(base)
+    )
+    if not public_laws:
+        public_laws = _dedupe_keep_order(session_laws + statutes_at_large)
+    return {
+        "public_laws": public_laws,
+        "statutes_at_large": statutes_at_large,
+        "usc_citations": usc_citations,
+        "session_laws": session_laws,
+    }
+
+
+def _extract_legislative_history(full_text: str, core_text: str) -> Dict[str, Any]:
+    enactment_blocks: List[str] = []
+    for match in re.finditer(r"\(([^)]{3,1800})\)", core_text):
+        block = _norm_space(match.group(1))
+        if not block:
+            continue
+        if re.search(
+            r"(Pub\.?\s*L\.?|\b\d+\s+Stat\.?\s+\d+\b|\bch\.\s*\d+)", block, flags=re.IGNORECASE
+        ):
+            enactment_blocks.append(block)
+
+    nonparen_pattern = re.compile(
+        r"([^.;]{0,160}(?:Pub\.?\s*L\.?\s*\d+[–-]\d+|\b\d+\s+Stat\.?\s+\d+\b|Act\s+[A-Z][a-z]{2,9}\.?\s+\d{1,2},\s+\d{4})[^.;]{0,260}[.;]?)",
+        re.IGNORECASE,
+    )
+    for match in nonparen_pattern.finditer(str(core_text or "")):
+        block = _norm_space(match.group(1))
+        if block:
+            enactment_blocks.append(block)
+
+    editorial_excerpt = ""
+    editorial_idx = str(full_text or "").find("Editorial Notes")
+    if editorial_idx >= 0:
+        editorial_excerpt = _norm_space(str(full_text or "")[editorial_idx : editorial_idx + 3000])
+
+    amendment_mentions = []
+    if editorial_excerpt:
+        amendment_mentions = _dedupe_keep_order(
+            PUBLIC_LAW_CITATION_RE.findall(editorial_excerpt)
+            + PUBLIC_LAW_LONGFORM_RE.findall(editorial_excerpt)
+            + PUBLIC_LAW_CONGRESS_RE.findall(editorial_excerpt)
+        )
+
+    return {
+        "enactment_citation_blocks": _dedupe_keep_order(enactment_blocks),
+        "amendment_public_laws": amendment_mentions,
+        "editorial_notes_excerpt": editorial_excerpt,
+    }
+
+
+def _validate_subsection_tree(nodes: List[Dict[str, Any]], *, max_depth: int = 6) -> List[str]:
+    issues: List[str] = []
+
+    def walk(siblings: List[Dict[str, Any]], depth: int, path: str) -> None:
+        if depth > max_depth:
+            issues.append(f"depth>{max_depth} at {path or 'root'}")
+
+        seen_labels: Dict[str, int] = {}
+        for index, node in enumerate(siblings, start=1):
+            label = str(node.get("label", ""))
+            kind = str(node.get("kind", ""))
+            text = _norm_space(str(node.get("text", "")))
+            children = node.get("subsections", [])
+
+            if label:
+                seen_labels[label] = seen_labels.get(label, 0) + 1
+                if seen_labels[label] > 1:
+                    issues.append(f"duplicate sibling label {label} at {path or 'root'}")
+
+            if not text and not children:
+                issues.append(f"empty leaf node {label or '#' + str(index)} at {path or 'root'}")
+
+            if kind not in {
+                "numeric",
+                "alpha_lower",
+                "alpha_upper",
+                "roman_lower",
+                "roman_upper",
+                "other",
+            }:
+                issues.append(f"unknown kind {kind} for {label or '#' + str(index)}")
+
+            child_path = f"{path}/{label}" if path else label
+            if isinstance(children, list) and children:
+                walk(children, depth + 1, child_path)
+
+    walk(nodes, depth=1, path="")
+    return sorted(set(issues))
+
+
+def _build_section_jsonld(section: Dict[str, Any]) -> Dict[str, Any]:
+    title_number = str(section.get("title_number") or "")
+    section_number = str(section.get("section_number") or "")
+    year_value = section.get("year")
+    source_url = str(section.get("source_url") or "")
+    title_name = str(section.get("title_name") or "")
+    heading = str(section.get("heading") or "")
+    text = str(section.get("text") or "")
+    chapter = section.get("chapter") or {}
+    preamble = str(section.get("preamble") or "")
+    citations = section.get("citations") or {}
+    legislative_history = section.get("legislative_history") or {}
+    subsections = section.get("subsections") or []
+    parser_warnings = section.get("parser_warnings") or []
+
+    return {
+        "@context": {
+            "@vocab": "https://schema.org/",
+            "usc": "https://uscode.house.gov/",
+            "titleNumber": "usc:titleNumber",
+            "sectionNumber": "usc:sectionNumber",
+            "sourceUrl": "usc:sourceUrl",
+        },
+        "@type": "Legislation",
+        "@id": f"urn:uscode:title:{title_number}:section:{section_number}:year:{year_value}",
+        "name": heading or f"Title {title_number} Section {section_number}",
+        "isPartOf": {
+            "@type": "CreativeWork",
+            "name": f"United States Code Title {title_number}",
+            "identifier": f"USC-{title_number}",
+        },
+        "legislationType": "statute",
+        "titleNumber": title_number,
+        "titleName": title_name,
+        "sectionNumber": section_number,
+        "dateModified": str(year_value) if year_value is not None else None,
+        "sourceUrl": source_url,
+        "chapter": chapter,
+        "preamble": preamble,
+        "citations": citations,
+        "legislativeHistory": legislative_history,
+        "text": text,
+        "subsections": subsections,
+        "parser_warnings": parser_warnings,
+    }
+
+
+def _write_title_jsonld(
+    *,
+    title_number: str,
+    year: Optional[int],
+    sections: List[Dict[str, Any]],
+    output_root: Path,
+) -> Path:
+    jsonld_dir = output_root / DEFAULT_USCODE_JSONLD_DIRNAME
+    jsonld_dir.mkdir(parents=True, exist_ok=True)
+    year_part = str(year) if year is not None else "unknown"
+    out_path = jsonld_dir / f"USCODE-{year_part}-title{title_number}.jsonld"
+
+    with out_path.open("w", encoding="utf-8") as handle:
+        for section in sections:
+            record = _build_section_jsonld(section)
+            handle.write(json.dumps(record, ensure_ascii=False) + "\n")
+    return out_path
+
+
+def _resolve_output_dir(output_dir: Optional[str] = None) -> Path:
+    if output_dir:
+        return Path(output_dir).expanduser().resolve()
+    return DEFAULT_USCODE_INDEX_DIR
+
+
+async def fetch_us_code_title(
+    title_num: str,
+    title_name: str,
+    include_metadata: bool = True,
+    rate_limit_delay: float = 1.0,
+    year: Optional[int] = None,
+    cache_dir: Optional[Path] = None,
+    force_download: bool = False,
+    keep_zip_cache: bool = False,
+    max_year_fallbacks: int = DEFAULT_USCODE_YEAR_FALLBACKS,
+    download_retries: int = DEFAULT_USCODE_DOWNLOAD_RETRIES,
+) -> Dict[str, Any]:
+    """Fetch a US Code title from GovInfo package ZIP content.
+
+    Args:
+        title_num: Title number (e.g., "18")
+        title_name: Title name (e.g., "Crimes and Criminal Procedure")
+        include_metadata: Include metadata like effective dates
+        rate_limit_delay: Delay between requests
+
+    Returns:
+        Dict with title data and sections
+    """
+    if not REQUESTS_AVAILABLE:
+        return {
+            "title_number": title_num,
+            "title_name": title_name,
+            "source": "US Code",
+            "source_url": "https://www.govinfo.gov/",
+            "scraped_at": datetime.now().isoformat(),
+            "error": "Required libraries unavailable: install requests and beautifulsoup4",
+            "sections": [],
+        }
+
+    cache_root = Path(cache_dir) if cache_dir is not None else DEFAULT_USCODE_CACHE_DIR
+    try:
+        session = _make_session()
+        candidate_years = _candidate_years_for_title(
+            session,
+            title_num=title_num,
+            year=year,
+            max_year_fallbacks=max_year_fallbacks,
+        )
+        if not candidate_years:
+            raise RuntimeError("Unable to discover an available USCODE package year")
+
+        last_error = None
+        tried_years: List[int] = []
+        source_attempts: List[Dict[str, Any]] = []
+        for selected_year in candidate_years:
+            tried_years.append(int(selected_year))
+            try:
+                downloaded = _download_title_zip(
+                    session,
+                    year=selected_year,
+                    title_num=title_num,
+                    cache_dir=cache_root / str(selected_year),
+                    force_download=bool(force_download),
+                    max_attempts=download_retries,
+                    include_official=True,
+                    include_recovery=False,
+                )
+                zip_path = Path(str(downloaded["zip_path"]))
+                sections = _extract_sections_from_zip(
+                    zip_path,
+                    year=selected_year,
+                    title_num=title_num,
+                    title_name=title_name,
+                    include_metadata=include_metadata,
+                    source_package=f"USCODE-{int(selected_year)}-title{title_num}",
+                )
+
+                if not keep_zip_cache:
+                    try:
+                        zip_path.unlink(missing_ok=True)
+                    except Exception:
+                        pass
+
+                await anyio.sleep(max(0.0, float(rate_limit_delay)))
+                source_attempts.extend(list(downloaded.get("attempts") or []))
+                source_name = str(downloaded.get("source") or "govinfo-content-zip")
+                return {
+                    "title_number": title_num,
+                    "title_name": title_name,
+                    "source": "US Code (GovInfo package ZIP)",
+                    "source_url": downloaded.get("source_url")
+                    or _govinfo_zip_url(selected_year, title_num),
+                    "source_authority_class": downloaded.get("source_authority_class")
+                    or "official",
+                    "package_source": source_name,
+                    "scraped_at": datetime.now().isoformat(),
+                    "year": selected_year,
+                    "zip_path": str(zip_path),
+                    "candidate_years": candidate_years,
+                    "tried_years": tried_years,
+                    "source_attempts": source_attempts,
+                    "sections": sections,
+                }
+            except Exception as year_exc:
+                source_attempts.append(
+                    {
+                        "source": "govinfo-package-zip",
+                        "year": int(selected_year),
+                        "status": "error",
+                        "error": str(year_exc),
+                    }
+                )
+                last_error = year_exc
+                continue
+
+        # Secondary official fallback source: U.S. House releasepoint HTM ZIP.
+        try:
+            target_year = int(year) if year is not None else int(candidate_years[0])
+            ushouse = _download_title_zip_ushouse(
+                session,
+                title_num=title_num,
+                cache_dir=cache_root / "ushouse",
+                force_download=bool(force_download),
+                max_attempts=download_retries,
+                year=target_year,
+            )
+            us_zip_path = Path(str(ushouse.get("zip_path")))
+            sections = _extract_sections_from_zip(
+                us_zip_path,
+                year=target_year,
+                title_num=title_num,
+                title_name=title_name,
+                include_metadata=include_metadata,
+                source_package=str(ushouse.get("source_package") or "USHOUSE-USCODE"),
+                section_url_base=str(ushouse.get("section_url_base") or "").strip() or None,
+            )
+
+            if not keep_zip_cache:
+                try:
+                    us_zip_path.unlink(missing_ok=True)
+                except Exception:
+                    pass
+
+            await anyio.sleep(max(0.0, float(rate_limit_delay)))
+            source_attempts.append(
+                {
+                    "source": "ushouse-releasepoint-htm-zip",
+                    "status": "success",
+                    "source_url": ushouse.get("source_url"),
+                    "source_congress": ushouse.get("source_congress"),
+                    "source_release": ushouse.get("source_release"),
+                }
+            )
+            return {
+                "title_number": title_num,
+                "title_name": title_name,
+                "source": "US Code (US House releasepoint HTM ZIP)",
+                "source_url": ushouse.get("source_url"),
+                "source_authority_class": "official",
+                "package_source": "ushouse-releasepoint-htm-zip",
+                "scraped_at": datetime.now().isoformat(),
+                "year": target_year,
+                "zip_path": str(us_zip_path),
+                "candidate_years": candidate_years,
+                "tried_years": tried_years,
+                "source_attempts": source_attempts,
+                "sections": sections,
+            }
+        except Exception as ushouse_exc:
+            source_attempts.append(
+                {
+                    "source": "ushouse-releasepoint-htm-zip",
+                    "status": "error",
+                    "error": str(ushouse_exc),
+                }
+            )
+            last_error = RuntimeError(
+                f"GovInfo package ZIP attempts failed ({tried_years}); "
+                f"US House fallback also failed: {ushouse_exc}"
+            )
+
+        # Recovery-only: Wayback (and optional Common Crawl) of the GovInfo ZIP.
+        for selected_year in tried_years or candidate_years:
+            try:
+                recovered = _download_title_zip(
+                    session,
+                    year=int(selected_year),
+                    title_num=title_num,
+                    cache_dir=cache_root / "recovery" / str(selected_year),
+                    force_download=bool(force_download),
+                    max_attempts=max(1, int(download_retries)),
+                    include_official=False,
+                    include_recovery=True,
+                )
+                if str(recovered.get("source_authority_class") or "") != "recovery":
+                    continue
+                rec_path = Path(str(recovered["zip_path"]))
+                sections = _extract_sections_from_zip(
+                    rec_path,
+                    year=int(selected_year),
+                    title_num=title_num,
+                    title_name=title_name,
+                    include_metadata=include_metadata,
+                    source_package=f"USCODE-{int(selected_year)}-title{title_num}",
+                )
+                if not keep_zip_cache:
+                    try:
+                        rec_path.unlink(missing_ok=True)
+                    except Exception:
+                        pass
+                source_attempts.extend(list(recovered.get("attempts") or []))
+                return {
+                    "title_number": title_num,
+                    "title_name": title_name,
+                    "source": "US Code (archive recovery ZIP)",
+                    "source_url": recovered.get("source_url"),
+                    "source_authority_class": "recovery",
+                    "package_source": recovered.get("source"),
+                    "scraped_at": datetime.now().isoformat(),
+                    "year": int(selected_year),
+                    "zip_path": str(rec_path),
+                    "candidate_years": candidate_years,
+                    "tried_years": tried_years,
+                    "source_attempts": source_attempts,
+                    "sections": sections,
+                }
+            except Exception as recovery_exc:
+                source_attempts.append(
+                    {
+                        "source": "archive-recovery-zip",
+                        "year": int(selected_year),
+                        "status": "error",
+                        "error": str(recovery_exc),
+                    }
+                )
+                last_error = recovery_exc
+                continue
+
+        raise RuntimeError(
+            f"Failed to fetch title {title_num} after trying years {tried_years}: {last_error}"
+        )
+    except Exception as e:
+        logger.error("Failed to fetch title %s: %s", title_num, e)
+        return {
+            "title_number": title_num,
+            "title_name": title_name,
+            "source": "US Code",
+            "source_url": "https://www.govinfo.gov/",
+            "scraped_at": datetime.now().isoformat(),
+            "error": str(e),
+            "candidate_years": [],
+            "tried_years": [],
+            "sections": [],
+        }
+
+
+async def search_us_code(
+    query: str,
+    titles: Optional[List[str]] = None,
+    max_results: int = 100,
+    limit: Optional[int] = None,  # Alias for max_results
+    index_path: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Search US Code for sections matching a query.
+
+    Args:
+        query: Search query string
+        titles: Optional list of title numbers to search within
+        max_results: Maximum number of results to return
+        limit: Alias for max_results (for compatibility)
+
+    Returns:
+        Dict with search results
+    """
+    if limit is not None:
+        max_results = limit
+
+    try:
+        query_text = str(query or "").strip().lower()
+        if not query_text:
+            return {
+                "status": "error",
+                "error": "Query must be non-empty",
+                "results": [],
+            }
+
+        title_filter = set(_normalize_titles(titles)) if titles else None
+        resolved_index_path = (
+            Path(index_path).expanduser().resolve() if index_path else DEFAULT_USCODE_INDEX_PATH
+        )
+        rows = _load_index_jsonl(resolved_index_path)
+        if not rows:
+            return {
+                "status": "error",
+                "error": "No local US Code index found. Run scrape_us_code() first.",
+                "results": [],
+            }
+
+        results: List[Dict[str, Any]] = []
+        for row in rows:
+            title_num = str(row.get("title_number") or "").strip()
+            if title_filter and title_num not in title_filter:
+                continue
+
+            heading = str(row.get("heading") or "")
+            text = str(row.get("text") or "")
+            haystack = f"{heading}\n{text}".lower()
+            if query_text not in haystack:
+                continue
+
+            idx = haystack.find(query_text)
+            lo = max(0, idx - 200)
+            hi = min(len(text), lo + 500)
+            snippet = text[lo:hi].strip() if text else heading[:500]
+
+            results.append(
+                {
+                    "title_number": title_num,
+                    "title_name": row.get("title_name"),
+                    "section_number": row.get("section_number"),
+                    "title": f"Title {title_num} § {row.get('section_number')}",
+                    "snippet": snippet,
+                    "url": row.get("source_url", ""),
+                    "year": row.get("year"),
+                }
+            )
+            if len(results) >= int(max_results):
+                break
+
+        return {
+            "status": "success",
+            "query": query,
+            "results": results,
+            "count": len(results),
+            "index_path": str(resolved_index_path),
+        }
+    except Exception as e:
+        logger.error("US Code search failed: %s", e)
+        return {
+            "status": "error",
+            "error": str(e),
+            "results": [],
+        }
+
+
+async def get_us_code_titles() -> Dict[str, Any]:
+    """Get list of all US Code titles.
+
+    Returns:
+        Dict containing:
+            - status: "success" or "error"
+            - titles: Dictionary mapping title numbers to names
+            - count: Number of titles
+            - error: Error message (if failed)
+    """
+    try:
+        return {
+            "status": "success",
+            "titles": US_CODE_TITLES,
+            "count": len(US_CODE_TITLES),
+            "source": "US Code - GovInfo package titles",
+        }
+    except Exception as e:
+        logger.error(f"Failed to get US Code titles: {e}")
+        return {"status": "error", "error": str(e), "titles": {}, "count": 0}
+
+
+async def scrape_us_code(
+    titles: Optional[List[str]] = None,
+    output_format: str = "json",
+    include_metadata: bool = True,
+    rate_limit_delay: float = 1.0,
+    max_sections: Optional[int] = None,
+    year: Optional[int] = None,
+    cache_dir: Optional[str] = None,
+    force_download: bool = False,
+    output_dir: Optional[str] = None,
+    keep_zip_cache: bool = False,
+    max_year_fallbacks: int = DEFAULT_USCODE_YEAR_FALLBACKS,
+    download_retries: int = DEFAULT_USCODE_DOWNLOAD_RETRIES,
+    continue_on_error: bool = True,
+) -> Dict[str, Any]:
+    """Scrape US Code sections and build a structured dataset.
+
+    Args:
+        titles: List of title numbers to scrape (e.g., ["1", "15", "18"]).
+                If None or ["all"], scrapes all titles.
+        output_format: Output format - "json" or "parquet"
+        include_metadata: Include section metadata (effective dates, amendments, etc.)
+        rate_limit_delay: Delay between requests in seconds (default 1.0)
+        max_sections: Maximum number of sections to scrape (for testing/limiting)
+
+    Returns:
+        Dict containing:
+            - status: "success" or "error"
+            - data: Scraped US Code sections
+            - metadata: Scraping metadata (titles, count, timing)
+            - output_format: Format of the data
+            - error: Error message (if failed)
+    """
+    try:
+        selected_titles = _normalize_titles(titles)
+        if not selected_titles:
+            return {
+                "status": "error",
+                "error": "No valid titles specified",
+                "data": [],
+                "metadata": {},
+            }
+
+        logger.info("Starting US Code scraping for titles: %s", selected_titles)
+        start_time = time.time()
+
+        if not REQUESTS_AVAILABLE:
+            return {
+                "status": "error",
+                "error": "Required libraries unavailable: install requests and beautifulsoup4",
+                "data": [],
+                "metadata": {},
+            }
+
+        output_root = _resolve_output_dir(output_dir)
+        output_root.mkdir(parents=True, exist_ok=True)
+        cache_root = (
+            Path(cache_dir).expanduser().resolve() if cache_dir else (output_root / "cache")
+        )
+        index_path = output_root / "uscode_index_latest.jsonl"
+        jsonld_paths: List[str] = []
+        scraped_titles: List[Dict[str, Any]] = []
+        failed_titles: List[Dict[str, Any]] = []
+        sections_count = 0
+
+        for title_num in selected_titles:
+            if max_sections and sections_count >= max_sections:
+                logger.info("Reached max_sections limit of %s", max_sections)
+                break
+
+            title_name = US_CODE_TITLES[title_num]
+            logger.info("Scraping Title %s: %s", title_num, title_name)
+
+            title_data = await fetch_us_code_title(
+                title_num,
+                title_name,
+                include_metadata=include_metadata,
+                rate_limit_delay=rate_limit_delay,
+                year=year,
+                cache_dir=cache_root,
+                force_download=force_download,
+                keep_zip_cache=keep_zip_cache,
+                max_year_fallbacks=max_year_fallbacks,
+                download_retries=download_retries,
+            )
+
+            title_error = str(title_data.get("error") or "").strip()
+            if title_error:
+                failed_titles.append(
+                    {
+                        "title_number": title_num,
+                        "title_name": title_name,
+                        "error": title_error,
+                        "candidate_years": title_data.get("candidate_years", []),
+                        "tried_years": title_data.get("tried_years", []),
+                    }
+                )
+                if not continue_on_error:
+                    break
+                continue
+
+            sections = (
+                list(title_data.get("sections") or []) if isinstance(title_data, dict) else []
+            )
+            if max_sections is not None and sections:
+                remaining = int(max_sections) - int(sections_count)
+                if remaining <= 0:
+                    sections = []
+                elif len(sections) > remaining:
+                    sections = sections[:remaining]
+                    title_data["sections"] = sections
+
+            if sections:
+                jsonld_path = _write_title_jsonld(
+                    title_number=title_num,
+                    year=title_data.get("year"),
+                    sections=sections,
+                    output_root=output_root,
+                )
+                title_data["jsonld_path"] = str(jsonld_path)
+                jsonld_paths.append(str(jsonld_path))
+                scraped_titles.append(title_data)
+                sections_count += len(sections)
+            else:
+                failed_titles.append(
+                    {
+                        "title_number": title_num,
+                        "title_name": title_name,
+                        "error": "No sections extracted",
+                        "candidate_years": title_data.get("candidate_years", []),
+                        "tried_years": title_data.get("tried_years", []),
+                    }
+                )
+                if not continue_on_error:
+                    break
+
+        elapsed_time = time.time() - start_time
+
+        flat_sections: List[Dict[str, Any]] = []
+        for title_blob in scraped_titles:
+            title_num = str(title_blob.get("title_number") or "")
+            title_name = str(title_blob.get("title_name") or US_CODE_TITLES.get(title_num, ""))
+            year_value = title_blob.get("year")
+            for section in title_blob.get("sections") or []:
+                if not isinstance(section, dict):
+                    continue
+                row = dict(section)
+                row.setdefault("title_number", title_num)
+                row.setdefault("title_name", title_name)
+                row.setdefault("year", year_value)
+                flat_sections.append(row)
+
+        _write_index_jsonl(flat_sections, index_path=index_path)
+
+        effective_year = None
+        if scraped_titles:
+            effective_year = scraped_titles[0].get("year")
+
+        metadata = {
+            "titles_requested": selected_titles,
+            "titles_requested_count": len(selected_titles),
+            "titles_scraped": [str(t.get("title_number")) for t in scraped_titles],
+            "titles_count": len(scraped_titles),
+            "failed_titles": failed_titles,
+            "failed_titles_count": len(failed_titles),
+            "sections_count": sections_count,
+            "elapsed_time_seconds": elapsed_time,
+            "scraped_at": datetime.now().isoformat(),
+            "source": "GovInfo USCODE package ZIP",
+            "rate_limit_delay": rate_limit_delay,
+            "include_metadata": include_metadata,
+            "year": effective_year,
+            "cache_dir": str(cache_root),
+            "index_path": str(index_path),
+            "output_dir": str(output_root),
+            "force_download": bool(force_download),
+            "keep_zip_cache": bool(keep_zip_cache),
+            "max_year_fallbacks": int(max_year_fallbacks),
+            "download_retries": int(download_retries),
+            "continue_on_error": bool(continue_on_error),
+            "jsonld_dir": str(output_root / DEFAULT_USCODE_JSONLD_DIRNAME),
+            "jsonld_files": jsonld_paths,
+        }
+
+        logger.info(
+            "Completed US Code scraping: %s sections in %.2fs", sections_count, elapsed_time
+        )
+
+        if not scraped_titles:
+            return {
+                "status": "error",
+                "error": "No US Code titles were successfully scraped",
+                "data": scraped_titles,
+                "metadata": metadata,
+                "output_format": output_format,
+                "note": "Comprehensive title-package ingestion from GovInfo USCODE ZIP sources.",
+            }
+
+        return {
+            "status": "success",
+            "data": scraped_titles,
+            "metadata": metadata,
+            "output_format": output_format,
+            "note": "Comprehensive title-package ingestion from GovInfo USCODE ZIP sources.",
+        }
+
+    except Exception as e:
+        logger.error("US Code scraping failed: %s", e)
+        return {
+            "status": "error",
+            "error": str(e),
+            "data": [],
+            "metadata": {},
+        }
+
+
+__all__ = [
+    "build_public_law_url",
+    "build_uscode_section_url",
+    "get_us_code_titles",
+    "scrape_us_code",
+    "search_us_code",
+    "fetch_us_code_title",
+]

scrapers_and_normalizers/ipfs_datasets_py/processors/legal_scrapers/federal_scrapers/us_code_verifier.py

@@ -0,0 +1,392 @@
+"""US Code verification engine — canonical domain module.
+
+Verification suite for testing the US Code scraper. Imported by:
+  ipfs_datasets_py.mcp_server.tools.legal_dataset_tools.verify_us_code_scraper
+
+Usage::
+
+    from ipfs_datasets_py.processors.legal_scrapers.us_code_verifier import (
+        USCodeVerifier,
+    )
+"""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List
+
+try:
+    from ipfs_datasets_py.processors.legal_scrapers.federal_scrapers.us_code_scraper import (
+        scrape_us_code,
+        get_us_code_titles,
+        search_us_code,
+    )
+except ImportError:
+    scrape_us_code = None  # type: ignore[assignment]
+    get_us_code_titles = None  # type: ignore[assignment]
+    search_us_code = None  # type: ignore[assignment]
+
+
+class USCodeVerifier:
+    """Verification suite for US Code scraper."""
+
+    def __init__(self):
+        self.results = {
+            "timestamp": datetime.now().isoformat(),
+            "tests": [],
+            "summary": {"total": 0, "passed": 0, "failed": 0, "warnings": 0},
+        }
+
+    def log_test(self, name: str, status: str, message: str, details: Dict[str, Any] = None):
+        """Log a test result."""
+        test_result = {"name": name, "status": status, "message": message, "details": details or {}}
+        self.results["tests"].append(test_result)
+        self.results["summary"]["total"] += 1
+
+        if status == "PASS":
+            self.results["summary"]["passed"] += 1
+            print(f"✅ {name}: {message}")
+        elif status == "FAIL":
+            self.results["summary"]["failed"] += 1
+            print(f"❌ {name}: {message}")
+        elif status == "WARN":
+            self.results["summary"]["warnings"] += 1
+            print(f"⚠️  {name}: {message}")
+
+        if details:
+            print(f"   Details: {json.dumps(details, indent=2)}")
+
+    async def test_get_titles(self):
+        """Test fetching US Code titles."""
+        print("\n" + "=" * 80)
+        print("TEST 1: Get US Code Titles")
+        print("=" * 80)
+
+        try:
+            result = await get_us_code_titles()
+
+            if result.get("status") == "success":
+                titles = result.get("titles", {})
+                count = len(titles)
+
+                if count >= 50:  # Should have ~54 titles
+                    self.log_test(
+                        "Get Titles",
+                        "PASS",
+                        f"Retrieved {count} US Code titles",
+                        {"title_count": count, "sample_titles": list(titles.items())[:5]},
+                    )
+                else:
+                    self.log_test(
+                        "Get Titles",
+                        "WARN",
+                        f"Retrieved only {count} titles (expected ~54)",
+                        {"title_count": count},
+                    )
+            else:
+                self.log_test(
+                    "Get Titles", "FAIL", f"Failed to get titles: {result.get('error')}", result
+                )
+        except Exception as e:
+            self.log_test("Get Titles", "FAIL", f"Exception: {str(e)}")
+
+    async def test_scrape_single_title(self):
+        """Test scraping a single title."""
+        print("\n" + "=" * 80)
+        print("TEST 2: Scrape Single Title (Title 1 - General Provisions)")
+        print("=" * 80)
+
+        try:
+            result = await scrape_us_code(
+                titles=["1"],
+                output_format="json",
+                include_metadata=True,
+                rate_limit_delay=1.0,
+                max_sections=10,  # Limit for testing
+            )
+
+            if result.get("status") == "success":
+                data = result.get("data", [])
+                metadata = result.get("metadata", {})
+
+                if len(data) > 0:
+                    self.log_test(
+                        "Scrape Single Title",
+                        "PASS",
+                        f"Scraped Title 1: {len(data)} sections",
+                        {
+                            "sections_count": len(data),
+                            "sample_section": data[0] if data else None,
+                            "metadata": metadata,
+                        },
+                    )
+                else:
+                    self.log_test(
+                        "Scrape Single Title", "WARN", "No sections scraped from Title 1", result
+                    )
+            else:
+                self.log_test(
+                    "Scrape Single Title", "FAIL", f"Failed: {result.get('error')}", result
+                )
+        except Exception as e:
+            self.log_test("Scrape Single Title", "FAIL", f"Exception: {str(e)}")
+
+    async def test_scrape_multiple_titles(self):
+        """Test scraping multiple titles."""
+        print("\n" + "=" * 80)
+        print("TEST 3: Scrape Multiple Titles (1, 15, 18)")
+        print("=" * 80)
+
+        try:
+            result = await scrape_us_code(
+                titles=["1", "15", "18"],
+                output_format="json",
+                include_metadata=True,
+                rate_limit_delay=1.0,
+                max_sections=5,  # Limit per title for testing
+            )
+
+            if result.get("status") == "success" or result.get("status") == "partial_success":
+                data = result.get("data", [])
+                metadata = result.get("metadata", {})
+
+                # Check if we got data from multiple titles
+                titles_found = set()
+                for section in data:
+                    if "title_number" in section:
+                        titles_found.add(section["title_number"])
+
+                if len(titles_found) >= 2:
+                    self.log_test(
+                        "Scrape Multiple Titles",
+                        "PASS",
+                        f"Scraped {len(titles_found)} titles: {sorted(titles_found)}",
+                        {
+                            "titles_found": sorted(titles_found),
+                            "total_sections": len(data),
+                            "metadata": metadata,
+                        },
+                    )
+                elif len(titles_found) == 1:
+                    self.log_test(
+                        "Scrape Multiple Titles",
+                        "WARN",
+                        f"Only scraped 1 title: {titles_found}",
+                        {"sections_count": len(data)},
+                    )
+                else:
+                    self.log_test(
+                        "Scrape Multiple Titles",
+                        "WARN",
+                        "No title information in scraped data",
+                        {"sections_count": len(data)},
+                    )
+            else:
+                self.log_test(
+                    "Scrape Multiple Titles", "FAIL", f"Failed: {result.get('error')}", result
+                )
+        except Exception as e:
+            self.log_test("Scrape Multiple Titles", "FAIL", f"Exception: {str(e)}")
+
+    async def test_data_structure(self):
+        """Test that scraped data has the correct structure."""
+        print("\n" + "=" * 80)
+        print("TEST 4: Validate Data Structure")
+        print("=" * 80)
+
+        try:
+            result = await scrape_us_code(
+                titles=["15"],  # Commerce and Trade
+                output_format="json",
+                include_metadata=True,
+                rate_limit_delay=1.0,
+                max_sections=3,
+            )
+
+            if result.get("status") in ["success", "partial_success"]:
+                data = result.get("data", [])
+
+                if not data:
+                    self.log_test("Data Structure", "WARN", "No data to validate structure", result)
+                    return
+
+                # Check required fields
+                required_fields = ["title_number", "title_name", "section_number"]
+                sample_section = data[0]
+
+                missing_fields = [f for f in required_fields if f not in sample_section]
+
+                if not missing_fields:
+                    self.log_test(
+                        "Data Structure",
+                        "PASS",
+                        "Data structure is valid",
+                        {"sample_section": sample_section, "total_sections": len(data)},
+                    )
+                else:
+                    self.log_test(
+                        "Data Structure",
+                        "WARN",
+                        f"Missing fields: {missing_fields}",
+                        {"sample_section": sample_section},
+                    )
+            else:
+                self.log_test(
+                    "Data Structure",
+                    "FAIL",
+                    f"Failed to scrape data: {result.get('error')}",
+                    result,
+                )
+        except Exception as e:
+            self.log_test("Data Structure", "FAIL", f"Exception: {str(e)}")
+
+    async def test_search_functionality(self):
+        """Test search functionality."""
+        print("\n" + "=" * 80)
+        print("TEST 5: Search Functionality")
+        print("=" * 80)
+
+        try:
+            result = await search_us_code(query="commerce", titles=["15"], limit=5)
+
+            if result.get("status") == "success":
+                results = result.get("results", [])
+
+                if len(results) > 0:
+                    self.log_test(
+                        "Search Functionality",
+                        "PASS",
+                        f"Found {len(results)} results for 'commerce'",
+                        {
+                            "result_count": len(results),
+                            "sample_result": results[0] if results else None,
+                        },
+                    )
+                else:
+                    self.log_test("Search Functionality", "WARN", "No search results found", result)
+            else:
+                self.log_test(
+                    "Search Functionality",
+                    "WARN",
+                    f"Search returned status: {result.get('status')}",
+                    result,
+                )
+        except Exception as e:
+            self.log_test("Search Functionality", "FAIL", f"Exception: {str(e)}")
+
+    async def test_metadata_inclusion(self):
+        """Test that metadata is included when requested."""
+        print("\n" + "=" * 80)
+        print("TEST 6: Metadata Inclusion")
+        print("=" * 80)
+
+        try:
+            # Test with metadata
+            result_with = await scrape_us_code(titles=["1"], include_metadata=True, max_sections=2)
+
+            # Test without metadata
+            result_without = await scrape_us_code(
+                titles=["1"], include_metadata=False, max_sections=2
+            )
+
+            metadata_present = bool(result_with.get("metadata"))
+
+            if metadata_present:
+                self.log_test(
+                    "Metadata Inclusion",
+                    "PASS",
+                    "Metadata is correctly included/excluded",
+                    {
+                        "with_metadata": bool(result_with.get("metadata")),
+                        "without_metadata": bool(result_without.get("metadata")),
+                        "sample_metadata": result_with.get("metadata"),
+                    },
+                )
+            else:
+                self.log_test(
+                    "Metadata Inclusion",
+                    "WARN",
+                    "Metadata not present in results",
+                    {"result_with": result_with, "result_without": result_without},
+                )
+        except Exception as e:
+            self.log_test("Metadata Inclusion", "FAIL", f"Exception: {str(e)}")
+
+    async def test_rate_limiting(self):
+        """Test that rate limiting is respected."""
+        print("\n" + "=" * 80)
+        print("TEST 7: Rate Limiting")
+        print("=" * 80)
+
+        try:
+            import time
+
+            start_time = time.time()
+
+            result = await scrape_us_code(
+                titles=["1"],
+                rate_limit_delay=2.0,  # 2 second delay
+                max_sections=3,
+            )
+
+            elapsed = time.time() - start_time
+
+            # Should take at least 4 seconds (2 delay * 2 requests minimum)
+            if elapsed >= 2.0:
+                self.log_test(
+                    "Rate Limiting",
+                    "PASS",
+                    f"Rate limiting appears to be working (took {elapsed:.2f}s)",
+                    {"elapsed_seconds": elapsed},
+                )
+            else:
+                self.log_test(
+                    "Rate Limiting",
+                    "WARN",
+                    f"Completed too quickly ({elapsed:.2f}s), rate limiting may not be working",
+                    {"elapsed_seconds": elapsed},
+                )
+        except Exception as e:
+            self.log_test("Rate Limiting", "FAIL", f"Exception: {str(e)}")
+
+    async def run_all_tests(self):
+        """Run all verification tests."""
+        print("\n" + "=" * 80)
+        print("US CODE SCRAPER VERIFICATION")
+        print("=" * 80)
+        print(f"Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+
+        # Run tests
+        await self.test_get_titles()
+        await self.test_scrape_single_title()
+        await self.test_scrape_multiple_titles()
+        await self.test_data_structure()
+        await self.test_search_functionality()
+        await self.test_metadata_inclusion()
+        await self.test_rate_limiting()
+
+        # Print summary
+        print("\n" + "=" * 80)
+        print("VERIFICATION SUMMARY")
+        print("=" * 80)
+        print(f"Total Tests: {self.results['summary']['total']}")
+        print(f"✅ Passed: {self.results['summary']['passed']}")
+        print(f"❌ Failed: {self.results['summary']['failed']}")
+        print(f"⚠️  Warnings: {self.results['summary']['warnings']}")
+
+        success_rate = (
+            (self.results["summary"]["passed"] / self.results["summary"]["total"] * 100)
+            if self.results["summary"]["total"] > 0
+            else 0
+        )
+        print(f"\nSuccess Rate: {success_rate:.1f}%")
+
+        # Save results
+        output_file = Path.home() / ".ipfs_datasets" / "us_code" / "verification_results.json"
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(output_file, "w") as f:
+            json.dump(self.results, f, indent=2)
+        print(f"\n📁 Results saved to: {output_file}")
+
+        # Return exit code
+        return 0 if self.results["summary"]["failed"] == 0 else 1

scrapers_and_normalizers/ipfs_datasets_py/processors/legal_scrapers/federal_scrapers/uscode_release_catalog.py

@@ -0,0 +1,2022 @@
+"""Exact all-title U.S. Code release catalog (USCIR-005).
+
+Resolves one approved exact release point, enumerates every expected title
+package in the sealed baseline span (Titles 1–52 and 54), acquires packages
+deterministically from sealed fixtures, checkpoints resume receipts, and
+reports missing/excluded packages.
+
+Design invariants
+-----------------
+* Fixture acquisition is deterministic (no live network I/O by default).
+* Title completeness is explicit: every required title is accepted, excluded,
+  or reported missing — never silently omitted.
+* Resume does not redownload verified packages whose checkpoint receipt and
+  on-disk checksum still match.
+* Every accepted package binds a content checksum and the approved release
+  point (or an explicitly approved mixed-vintage override).
+* Proposed-latest discovery cannot mint final provenance; admission requires
+  an approved exact release (USCIR-004).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Optional, Sequence, Union
+
+from ipfs_datasets_py.processors.legal_data.uscode_source_policy import (
+    CANONICAL_USCODE_TITLES,
+    CURRENTNESS_DISCLAIMER,
+    DEFAULT_ACQUIRED_AT,
+    DEFAULT_APPROVED_AT,
+    DEFAULT_APPROVED_CONGRESS,
+    DEFAULT_APPROVED_RELEASE,
+    DEFAULT_APPROVED_RELEASE_POINT,
+    DEFAULT_DISCOVERED_AT,
+    DEFAULT_PROVIDER_OLRC,
+    EXPECTED_TITLE_COUNT,
+    USHOUSE_DOWNLOAD_PAGE,
+    AllTitleReleaseManifest,
+    ApprovedReleasePoint,
+    ExclusionKind,
+    HardCodedLatestEditionError,
+    MissingApprovedReleaseError,
+    ProposedReleasePoint,
+    ReleasePointRole,
+    ResumeReceiptError,
+    SourceProvider,
+    TitleExclusion,
+    TitlePackageProvenance,
+    TitlePackageStatus,
+    TitleResumeReceipt,
+    UnapprovedMixedVintageError,
+    UnapprovedProposedReleaseError,
+    UscodeSourcePolicy,
+    UscodeSourcePolicyError,
+    VerificationResult,
+    canonical_json_dumps,
+    content_sha256,
+    digest_mapping,
+    expected_title_package_sha256,
+    normalize_title,
+    parse_release_point_id,
+    require_approved_exact,
+    require_canonical_title,
+    titles_missing_from_manifest,
+    ushouse_releasepoint_zip_url,
+    ushouse_title_code,
+)
+
+SCHEMA_VERSION = "uscode-release-catalog-v1"
+FIXTURE_SCHEMA_VERSION = "uscode-release-catalog-fixture-v1"
+
+# Fixture identity defaults (aligned with USCIR-004 sealed release).
+DEFAULT_FIXTURE_ID = "uscode-catalog-us-pl-118-45"
+DEFAULT_CATALOG_APPROVED_BY = "uscir-005-fixture-seal"
+
+PathLike = Union[str, Path]
+JsonMapping = Mapping[str, Any]
+
+
+# ---------------------------------------------------------------------------
+# Errors
+# ---------------------------------------------------------------------------
+
+
+class UscodeReleaseCatalogError(ValueError):
+    """Base error for all-title release catalog failures."""
+
+
+class CatalogFixtureSchemaError(UscodeReleaseCatalogError):
+    """Raised when the sealed catalog fixture recipe is malformed."""
+
+
+class CatalogCompletenessError(UscodeReleaseCatalogError):
+    """Raised when title completeness fails closed and enforcement is requested."""
+
+
+class CatalogCheckpointError(UscodeReleaseCatalogError):
+    """Raised when a catalog checkpoint is malformed or non-atomic write fails."""
+
+
+class CatalogAcquisitionError(UscodeReleaseCatalogError):
+    """Raised when package acquisition cannot bind checksum and release point."""
+
+
+# ---------------------------------------------------------------------------
+# Enums
+# ---------------------------------------------------------------------------
+
+
+class PackageDisposition(str, Enum):
+    """Per-title disposition after catalog acquisition or resume."""
+
+    ACCEPTED = "accepted"
+    EXCLUDED = "excluded"
+    MISSING = "missing"
+    SKIPPED_VERIFIED = "skipped_verified"
+    REDOWNLOAD = "redownload"
+    VERIFY_FAILED = "verify_failed"
+    FAILED = "failed"
+
+    @classmethod
+    def coerce(cls, value: Any) -> "PackageDisposition":
+        if isinstance(value, PackageDisposition):
+            return value
+        text = str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
+        for item in cls:
+            if item.value == text or item.name.lower() == text:
+                return item
+        raise UscodeReleaseCatalogError(f"unknown package disposition: {value!r}")
+
+
+class CatalogAcquisitionMode(str, Enum):
+    """How packages were obtained."""
+
+    FIXTURE = "fixture"
+    RESUME = "resume"
+    POLICY = "policy"
+
+    @classmethod
+    def coerce(cls, value: Any) -> "CatalogAcquisitionMode":
+        if isinstance(value, CatalogAcquisitionMode):
+            return value
+        text = str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
+        for item in cls:
+            if item.value == text or item.name.lower() == text:
+                return item
+        raise UscodeReleaseCatalogError(f"unknown acquisition mode: {value!r}")
+
+
+# ---------------------------------------------------------------------------
+# Records
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True, slots=True)
+class TitlePackageSpec:
+    """Expected package descriptor for one title under the approved release."""
+
+    title: str
+    release_point: str
+    package_id: str
+    source_url: str
+    expected_sha256: str
+    provider: SourceProvider = SourceProvider.OLRC_HOUSE
+    format_kind: str = "xml"
+    required: bool = True
+    exclusion: Optional[TitleExclusion] = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "title", require_canonical_title(self.title))
+        rp = str(self.release_point)
+        if not rp.upper().startswith("USCODE-"):
+            rp, _, _ = parse_release_point_id(rp)
+        object.__setattr__(self, "release_point", rp)
+        object.__setattr__(self, "package_id", str(self.package_id).strip())
+        if not self.package_id:
+            raise UscodeReleaseCatalogError("package_id must be non-empty")
+        object.__setattr__(self, "source_url", str(self.source_url).strip())
+        if not self.source_url:
+            raise UscodeReleaseCatalogError("source_url must be non-empty")
+        sha = str(self.expected_sha256).strip().lower()
+        if len(sha) != 64 or any(c not in "0123456789abcdef" for c in sha):
+            raise UscodeReleaseCatalogError(
+                f"expected_sha256 must be a lowercase 64-char hex SHA-256, got {self.expected_sha256!r}"
+            )
+        object.__setattr__(self, "expected_sha256", sha)
+        object.__setattr__(
+            self, "provider", SourceProvider.coerce(self.provider).canonical()
+        )
+        object.__setattr__(
+            self, "format_kind", str(self.format_kind or "xml").strip().lower()
+        )
+        if self.exclusion is not None and not isinstance(self.exclusion, TitleExclusion):
+            if isinstance(self.exclusion, Mapping):
+                object.__setattr__(self, "exclusion", TitleExclusion.from_dict(self.exclusion))
+            else:
+                raise UscodeReleaseCatalogError("exclusion must be a TitleExclusion or mapping")
+        if not isinstance(self.metadata, Mapping):
+            raise UscodeReleaseCatalogError("metadata must be a mapping")
+        object.__setattr__(self, "metadata", dict(self.metadata))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "exclusion": None if self.exclusion is None else self.exclusion.to_dict(),
+            "expected_sha256": self.expected_sha256,
+            "format_kind": self.format_kind,
+            "metadata": dict(sorted(self.metadata.items(), key=lambda kv: str(kv[0]))),
+            "package_id": self.package_id,
+            "provider": self.provider.value,
+            "release_point": self.release_point,
+            "required": bool(self.required),
+            "source_url": self.source_url,
+            "title": self.title,
+        }
+
+    @classmethod
+    def from_dict(cls, value: JsonMapping) -> "TitlePackageSpec":
+        if not isinstance(value, Mapping):
+            raise UscodeReleaseCatalogError("title package spec must be a mapping")
+        return cls(
+            title=str(value.get("title")),
+            release_point=str(value.get("release_point")),
+            package_id=str(value.get("package_id") or value.get("release_point")),
+            source_url=str(value.get("source_url")),
+            expected_sha256=str(
+                value.get("expected_sha256")
+                or value.get("content_sha256")
+                or value.get("artifact_sha256")
+            ),
+            provider=SourceProvider.coerce(value.get("provider") or DEFAULT_PROVIDER_OLRC),
+            format_kind=str(value.get("format_kind") or value.get("format") or "xml"),
+            required=bool(value.get("required", True)),
+            exclusion=value.get("exclusion"),
+            metadata=value.get("metadata") or {},
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class TitlePackageAcquisition:
+    """Result of acquiring (or skipping) one title package.
+
+    Accepted packages always bind ``content_sha256`` and ``release_point``.
+    """
+
+    title: str
+    disposition: PackageDisposition
+    release_point: Optional[str]
+    content_sha256: Optional[str]
+    package_id: Optional[str] = None
+    source_url: Optional[str] = None
+    status: TitlePackageStatus = TitlePackageStatus.PENDING
+    verification: VerificationResult = VerificationResult.UNVERIFIED
+    provenance: Optional[TitlePackageProvenance] = None
+    resume_receipt: Optional[TitleResumeReceipt] = None
+    exclusion: Optional[TitleExclusion] = None
+    redownloaded: bool = False
+    notes: Optional[str] = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "title", require_canonical_title(self.title))
+        object.__setattr__(self, "disposition", PackageDisposition.coerce(self.disposition))
+        object.__setattr__(self, "status", TitlePackageStatus.coerce(self.status))
+        object.__setattr__(
+            self, "verification", VerificationResult.coerce(self.verification)
+        )
+        if self.release_point is not None:
+            rp = str(self.release_point)
+            if not rp.upper().startswith("USCODE-"):
+                rp, _, _ = parse_release_point_id(rp)
+            object.__setattr__(self, "release_point", rp)
+        if self.content_sha256 is not None:
+            sha = str(self.content_sha256).strip().lower()
+            if len(sha) != 64 or any(c not in "0123456789abcdef" for c in sha):
+                raise CatalogAcquisitionError(
+                    f"content_sha256 must be a lowercase 64-char hex SHA-256 for title {self.title}"
+                )
+            object.__setattr__(self, "content_sha256", sha)
+        if not isinstance(self.metadata, Mapping):
+            raise UscodeReleaseCatalogError("metadata must be a mapping")
+        object.__setattr__(self, "metadata", dict(self.metadata))
+
+        # Accepted packages must bind checksum + release point.
+        if self.disposition is PackageDisposition.ACCEPTED:
+            if not self.release_point:
+                raise CatalogAcquisitionError(
+                    f"accepted package for title {self.title} must bind release_point"
+                )
+            if not self.content_sha256:
+                raise CatalogAcquisitionError(
+                    f"accepted package for title {self.title} must bind content_sha256"
+                )
+            if self.verification is not VerificationResult.VERIFIED:
+                raise CatalogAcquisitionError(
+                    f"accepted package for title {self.title} requires verification=verified"
+                )
+
+        if self.disposition is PackageDisposition.EXCLUDED and self.exclusion is None:
+            raise CatalogAcquisitionError(
+                f"excluded package for title {self.title} requires an exclusion record"
+            )
+
+    @property
+    def is_accepted(self) -> bool:
+        return self.disposition is PackageDisposition.ACCEPTED
+
+    @property
+    def is_complete_slot(self) -> bool:
+        """True when this title is accounted for (accepted, excluded, or skipped)."""
+
+        return self.disposition in {
+            PackageDisposition.ACCEPTED,
+            PackageDisposition.EXCLUDED,
+            PackageDisposition.SKIPPED_VERIFIED,
+        }
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "content_sha256": self.content_sha256,
+            "disposition": self.disposition.value,
+            "exclusion": None if self.exclusion is None else self.exclusion.to_dict(),
+            "metadata": dict(sorted(self.metadata.items(), key=lambda kv: str(kv[0]))),
+            "notes": self.notes,
+            "package_id": self.package_id,
+            "provenance": None if self.provenance is None else self.provenance.to_dict(),
+            "redownloaded": bool(self.redownloaded),
+            "release_point": self.release_point,
+            "resume_receipt": (
+                None if self.resume_receipt is None else self.resume_receipt.to_dict()
+            ),
+            "source_url": self.source_url,
+            "status": self.status.value,
+            "title": self.title,
+            "verification": self.verification.value,
+        }
+
+    @classmethod
+    def from_dict(cls, value: JsonMapping) -> "TitlePackageAcquisition":
+        if not isinstance(value, Mapping):
+            raise UscodeReleaseCatalogError("title package acquisition must be a mapping")
+        provenance_raw = value.get("provenance")
+        receipt_raw = value.get("resume_receipt")
+        exclusion_raw = value.get("exclusion")
+        return cls(
+            title=str(value.get("title")),
+            disposition=PackageDisposition.coerce(value.get("disposition")),
+            release_point=value.get("release_point"),
+            content_sha256=value.get("content_sha256"),
+            package_id=value.get("package_id"),
+            source_url=value.get("source_url"),
+            status=TitlePackageStatus.coerce(
+                value.get("status") or TitlePackageStatus.PENDING
+            ),
+            verification=VerificationResult.coerce(
+                value.get("verification") or VerificationResult.UNVERIFIED
+            ),
+            provenance=(
+                None
+                if provenance_raw is None
+                else TitlePackageProvenance.from_dict(provenance_raw)
+            ),
+            resume_receipt=(
+                None
+                if receipt_raw is None
+                else TitleResumeReceipt.from_dict(receipt_raw)
+            ),
+            exclusion=(
+                None
+                if exclusion_raw is None
+                else TitleExclusion.from_dict(exclusion_raw)
+            ),
+            redownloaded=bool(value.get("redownloaded", False)),
+            notes=value.get("notes"),
+            metadata=value.get("metadata") or {},
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class TitleCompletenessReport:
+    """Explicit title completeness for one catalog acquisition.
+
+    Completeness is complete only when every required title is either accepted
+    (or skipped-verified on resume) or explicitly excluded — never when titles
+    are silently absent.
+    """
+
+    expected_titles: tuple[str, ...]
+    expected_count: int
+    present_titles: tuple[str, ...]
+    accepted_titles: tuple[str, ...]
+    excluded_titles: tuple[str, ...]
+    missing_titles: tuple[str, ...]
+    failed_titles: tuple[str, ...]
+    skipped_verified_titles: tuple[str, ...]
+    is_complete: bool
+    notes: Optional[str] = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self, "expected_titles", tuple(str(t) for t in self.expected_titles)
+        )
+        object.__setattr__(
+            self, "present_titles", tuple(str(t) for t in self.present_titles)
+        )
+        object.__setattr__(
+            self, "accepted_titles", tuple(str(t) for t in self.accepted_titles)
+        )
+        object.__setattr__(
+            self, "excluded_titles", tuple(str(t) for t in self.excluded_titles)
+        )
+        object.__setattr__(
+            self, "missing_titles", tuple(str(t) for t in self.missing_titles)
+        )
+        object.__setattr__(
+            self, "failed_titles", tuple(str(t) for t in self.failed_titles)
+        )
+        object.__setattr__(
+            self,
+            "skipped_verified_titles",
+            tuple(str(t) for t in self.skipped_verified_titles),
+        )
+        if not isinstance(self.expected_count, int) or self.expected_count < 0:
+            raise UscodeReleaseCatalogError("expected_count must be a non-negative int")
+        if not isinstance(self.metadata, Mapping):
+            raise UscodeReleaseCatalogError("metadata must be a mapping")
+        object.__setattr__(self, "metadata", dict(self.metadata))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "accepted_titles": list(self.accepted_titles),
+            "excluded_titles": list(self.excluded_titles),
+            "expected_count": self.expected_count,
+            "expected_titles": list(self.expected_titles),
+            "failed_titles": list(self.failed_titles),
+            "is_complete": bool(self.is_complete),
+            "metadata": dict(sorted(self.metadata.items(), key=lambda kv: str(kv[0]))),
+            "missing_titles": list(self.missing_titles),
+            "notes": self.notes,
+            "present_titles": list(self.present_titles),
+            "skipped_verified_titles": list(self.skipped_verified_titles),
+        }
+
+    @classmethod
+    def from_dict(cls, value: JsonMapping) -> "TitleCompletenessReport":
+        if not isinstance(value, Mapping):
+            raise UscodeReleaseCatalogError("completeness report must be a mapping")
+        return cls(
+            expected_titles=tuple(value.get("expected_titles") or ()),
+            expected_count=int(value.get("expected_count") or 0),
+            present_titles=tuple(value.get("present_titles") or ()),
+            accepted_titles=tuple(value.get("accepted_titles") or ()),
+            excluded_titles=tuple(value.get("excluded_titles") or ()),
+            missing_titles=tuple(value.get("missing_titles") or ()),
+            failed_titles=tuple(value.get("failed_titles") or ()),
+            skipped_verified_titles=tuple(value.get("skipped_verified_titles") or ()),
+            is_complete=bool(value.get("is_complete")),
+            notes=value.get("notes"),
+            metadata=value.get("metadata") or {},
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class CatalogAcquisitionResult:
+    """Sealed outcome of an all-title catalog acquisition or resume pass."""
+
+    approved_release: ApprovedReleasePoint
+    packages: Mapping[str, TitlePackageAcquisition]
+    completeness: TitleCompletenessReport
+    mode: CatalogAcquisitionMode
+    resume_receipts: Mapping[str, TitleResumeReceipt] = field(default_factory=dict)
+    proposed_release: Optional[ProposedReleasePoint] = None
+    expected_packages: Mapping[str, TitlePackageSpec] = field(default_factory=dict)
+    currentness_disclaimer: str = CURRENTNESS_DISCLAIMER
+    schema_version: str = SCHEMA_VERSION
+    fixture_id: Optional[str] = None
+    notes: Optional[str] = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+    download_count: int = 0
+    skip_count: int = 0
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.approved_release, ApprovedReleasePoint):
+            object.__setattr__(
+                self, "approved_release", require_approved_exact(self.approved_release)
+            )
+        object.__setattr__(self, "mode", CatalogAcquisitionMode.coerce(self.mode))
+
+        package_map: dict[str, TitlePackageAcquisition] = {}
+        for key, pkg in (self.packages or {}).items():
+            if isinstance(pkg, TitlePackageAcquisition):
+                record = pkg
+            elif isinstance(pkg, Mapping):
+                record = TitlePackageAcquisition.from_dict(pkg)
+            else:
+                raise UscodeReleaseCatalogError(
+                    "packages values must be TitlePackageAcquisition or mapping"
+                )
+            package_map[record.title] = record
+        object.__setattr__(self, "packages", package_map)
+
+        receipt_map: dict[str, TitleResumeReceipt] = {}
+        for key, receipt in (self.resume_receipts or {}).items():
+            if isinstance(receipt, TitleResumeReceipt):
+                record = receipt
+            elif isinstance(receipt, Mapping):
+                record = TitleResumeReceipt.from_dict(receipt)
+            else:
+                raise ResumeReceiptError(
+                    "resume_receipts values must be TitleResumeReceipt or mapping"
+                )
+            receipt_map[record.title] = record
+        object.__setattr__(self, "resume_receipts", receipt_map)
+
+        spec_map: dict[str, TitlePackageSpec] = {}
+        for key, spec in (self.expected_packages or {}).items():
+            if isinstance(spec, TitlePackageSpec):
+                record = spec
+            elif isinstance(spec, Mapping):
+                record = TitlePackageSpec.from_dict(spec)
+            else:
+                raise UscodeReleaseCatalogError(
+                    "expected_packages values must be TitlePackageSpec or mapping"
+                )
+            spec_map[record.title] = record
+        object.__setattr__(self, "expected_packages", spec_map)
+
+        if not isinstance(self.completeness, TitleCompletenessReport):
+            if isinstance(self.completeness, Mapping):
+                object.__setattr__(
+                    self, "completeness", TitleCompletenessReport.from_dict(self.completeness)
+                )
+            else:
+                raise UscodeReleaseCatalogError(
+                    "completeness must be a TitleCompletenessReport or mapping"
+                )
+
+        if self.proposed_release is not None and not isinstance(
+            self.proposed_release, ProposedReleasePoint
+        ):
+            if isinstance(self.proposed_release, Mapping):
+                object.__setattr__(
+                    self,
+                    "proposed_release",
+                    ProposedReleasePoint.from_dict(self.proposed_release),
+                )
+            else:
+                raise UscodeReleaseCatalogError(
+                    "proposed_release must be a ProposedReleasePoint or mapping"
+                )
+
+        object.__setattr__(
+            self,
+            "currentness_disclaimer",
+            str(self.currentness_disclaimer or CURRENTNESS_DISCLAIMER),
+        )
+        object.__setattr__(self, "schema_version", str(self.schema_version or SCHEMA_VERSION))
+        if not isinstance(self.metadata, Mapping):
+            raise UscodeReleaseCatalogError("metadata must be a mapping")
+        object.__setattr__(self, "metadata", dict(self.metadata))
+        if not isinstance(self.download_count, int) or self.download_count < 0:
+            raise UscodeReleaseCatalogError("download_count must be a non-negative int")
+        if not isinstance(self.skip_count, int) or self.skip_count < 0:
+            raise UscodeReleaseCatalogError("skip_count must be a non-negative int")
+
+        # Fail closed: every accepted / skipped-verified package binds checksum + release point.
+        for title, pkg in self.packages.items():
+            if pkg.disposition in {
+                PackageDisposition.ACCEPTED,
+                PackageDisposition.SKIPPED_VERIFIED,
+            }:
+                if not pkg.content_sha256 or not pkg.release_point:
+                    raise CatalogAcquisitionError(
+                        f"accepted package for title {title} missing checksum or release_point"
+                    )
+
+    @property
+    def accepted_packages(self) -> Mapping[str, TitlePackageAcquisition]:
+        return {
+            t: p
+            for t, p in self.packages.items()
+            if p.disposition
+            in {PackageDisposition.ACCEPTED, PackageDisposition.SKIPPED_VERIFIED}
+        }
+
+    def result_digest(self) -> str:
+        return digest_mapping(self.to_dict())
+
+    def to_manifest(self) -> AllTitleReleaseManifest:
+        """Project accepted/excluded packages into an all-title release manifest."""
+
+        titles: dict[str, TitlePackageProvenance] = {}
+        receipts: dict[str, TitleResumeReceipt] = {}
+        for title, pkg in self.packages.items():
+            if pkg.provenance is not None:
+                titles[title] = pkg.provenance
+            if pkg.resume_receipt is not None:
+                receipts[title] = pkg.resume_receipt
+            elif title in self.resume_receipts:
+                receipts[title] = self.resume_receipts[title]
+        return AllTitleReleaseManifest(
+            approved_release=self.approved_release,
+            titles=titles,
+            resume_receipts=receipts,
+            proposed_release=self.proposed_release,
+            currentness_disclaimer=self.currentness_disclaimer,
+            schema_version=self.schema_version
+            if self.schema_version.startswith("uscode-source-policy")
+            else "uscode-source-policy-v1",
+            notes=self.notes,
+            metadata={
+                "catalog_schema_version": SCHEMA_VERSION,
+                "fixture_id": self.fixture_id,
+                "mode": self.mode.value,
+                **dict(self.metadata),
+            },
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "approved_release": self.approved_release.to_dict(),
+            "completeness": self.completeness.to_dict(),
+            "currentness_disclaimer": self.currentness_disclaimer,
+            "download_count": self.download_count,
+            "expected_packages": {
+                k: v.to_dict()
+                for k, v in sorted(self.expected_packages.items(), key=lambda kv: kv[0])
+            },
+            "fixture_id": self.fixture_id,
+            "metadata": dict(sorted(self.metadata.items(), key=lambda kv: str(kv[0]))),
+            "mode": self.mode.value,
+            "notes": self.notes,
+            "packages": {
+                k: v.to_dict() for k, v in sorted(self.packages.items(), key=lambda kv: kv[0])
+            },
+            "proposed_release": (
+                None if self.proposed_release is None else self.proposed_release.to_dict()
+            ),
+            "resume_receipts": {
+                k: v.to_dict()
+                for k, v in sorted(self.resume_receipts.items(), key=lambda kv: kv[0])
+            },
+            "schema_version": self.schema_version,
+            "skip_count": self.skip_count,
+        }
+
+    @classmethod
+    def from_dict(cls, value: JsonMapping) -> "CatalogAcquisitionResult":
+        if not isinstance(value, Mapping):
+            raise UscodeReleaseCatalogError("catalog acquisition result must be a mapping")
+        approved_raw = value.get("approved_release") or value.get("approved")
+        if approved_raw is None:
+            raise MissingApprovedReleaseError("approved_release is required")
+        return cls(
+            approved_release=require_approved_exact(approved_raw),
+            packages=value.get("packages") or {},
+            completeness=value.get("completeness") or {},
+            mode=CatalogAcquisitionMode.coerce(
+                value.get("mode") or CatalogAcquisitionMode.FIXTURE
+            ),
+            resume_receipts=value.get("resume_receipts") or {},
+            proposed_release=value.get("proposed_release"),
+            expected_packages=value.get("expected_packages") or {},
+            currentness_disclaimer=str(
+                value.get("currentness_disclaimer") or CURRENTNESS_DISCLAIMER
+            ),
+            schema_version=str(value.get("schema_version") or SCHEMA_VERSION),
+            fixture_id=value.get("fixture_id"),
+            notes=value.get("notes"),
+            metadata=value.get("metadata") or {},
+            download_count=int(value.get("download_count") or 0),
+            skip_count=int(value.get("skip_count") or 0),
+        )
+
+
+# ---------------------------------------------------------------------------
+# Completeness helpers
+# ---------------------------------------------------------------------------
+
+
+def build_completeness_report(
+    packages: Mapping[str, TitlePackageAcquisition] | Iterable[TitlePackageAcquisition],
+    *,
+    expected_titles: Sequence[str] = CANONICAL_USCODE_TITLES,
+    notes: Optional[str] = None,
+    metadata: Optional[Mapping[str, Any]] = None,
+) -> TitleCompletenessReport:
+    """Build an explicit title completeness report from package dispositions."""
+
+    expected = tuple(require_canonical_title(t) for t in expected_titles)
+    expected_set = set(expected)
+
+    if isinstance(packages, Mapping):
+        pkg_iter: Iterable[TitlePackageAcquisition] = packages.values()
+    else:
+        pkg_iter = packages
+
+    by_title: dict[str, TitlePackageAcquisition] = {}
+    for pkg in pkg_iter:
+        if not isinstance(pkg, TitlePackageAcquisition):
+            raise UscodeReleaseCatalogError(
+                "packages must be TitlePackageAcquisition records"
+            )
+        by_title[pkg.title] = pkg
+
+    accepted: list[str] = []
+    excluded: list[str] = []
+    missing: list[str] = []
+    failed: list[str] = []
+    skipped: list[str] = []
+    present: list[str] = []
+
+    for title in expected:
+        pkg = by_title.get(title)
+        if pkg is None:
+            missing.append(title)
+            continue
+        present.append(title)
+        if pkg.disposition is PackageDisposition.ACCEPTED:
+            accepted.append(title)
+        elif pkg.disposition is PackageDisposition.EXCLUDED:
+            excluded.append(title)
+        elif pkg.disposition is PackageDisposition.SKIPPED_VERIFIED:
+            skipped.append(title)
+            accepted.append(title)  # accounted as present/verified
+        elif pkg.disposition is PackageDisposition.MISSING:
+            missing.append(title)
+            if title in present:
+                # Keep in present if explicitly reported as missing disposition
+                # after being listed — treat as not present for completeness.
+                present.remove(title)
+        elif pkg.disposition in {
+            PackageDisposition.FAILED,
+            PackageDisposition.VERIFY_FAILED,
+            PackageDisposition.REDOWNLOAD,
+        }:
+            failed.append(title)
+        else:
+            failed.append(title)
+
+    # Titles outside expected set are ignored for completeness, but recorded.
+    extra = sorted(t for t in by_title if t not in expected_set)
+
+    is_complete = (
+        len(missing) == 0
+        and len(failed) == 0
+        and (len(accepted) + len(excluded)) == len(expected)
+    )
+
+    return TitleCompletenessReport(
+        expected_titles=expected,
+        expected_count=len(expected),
+        present_titles=tuple(present),
+        accepted_titles=tuple(accepted),
+        excluded_titles=tuple(excluded),
+        missing_titles=tuple(missing),
+        failed_titles=tuple(failed),
+        skipped_verified_titles=tuple(skipped),
+        is_complete=is_complete,
+        notes=notes,
+        metadata={
+            **dict(metadata or {}),
+            "extra_titles": extra,
+            "accounted_count": len(accepted) + len(excluded),
+        },
+    )
+
+
+# ---------------------------------------------------------------------------
+# Fixture recipe / IO
+# ---------------------------------------------------------------------------
+
+
+def default_catalog_fixture_path() -> Path:
+    """Return the sealed all-title release-catalog fixture path."""
+
+    here = Path(__file__).resolve()
+    # processors/legal_scrapers/federal_scrapers/thisfile → repo root is parents[4]
+    candidates = [
+        here.parents[4] / "tests" / "fixtures" / "legal_ir" / "uscode_release_catalog.json",
+        Path.cwd() / "tests" / "fixtures" / "legal_ir" / "uscode_release_catalog.json",
+    ]
+    for path in candidates:
+        if path.is_file():
+            return path
+    return candidates[0]
+
+
+def build_default_catalog_fixture_payload(
+    *,
+    release_point: str = DEFAULT_APPROVED_RELEASE_POINT,
+    congress: str = DEFAULT_APPROVED_CONGRESS,
+    release: str = DEFAULT_APPROVED_RELEASE,
+    approved_by: str = DEFAULT_CATALOG_APPROVED_BY,
+    approved_at: str = DEFAULT_APPROVED_AT,
+    discovered_at: str = DEFAULT_DISCOVERED_AT,
+    acquired_at: str = DEFAULT_ACQUIRED_AT,
+    excluded_titles: Optional[Mapping[str, Mapping[str, Any]]] = None,
+    missing_titles: Optional[Sequence[str]] = None,
+) -> dict[str, Any]:
+    """Build a compact recipe for the sealed all-title catalog fixture.
+
+    Stores generators and shared release identity rather than 53 fully expanded
+    package envelopes, keeping the fixture under admission budgets.
+    """
+
+    canonical, congress_s, release_s = parse_release_point_id(
+        release_point if release_point else f"{congress}/{release}"
+    )
+    # Recipe-level exclusions (title → exclusion mapping). Default happy-path
+    # fixture admits all 53 packages; callers/tests inject exclusions when
+    # exercising the excluded disposition path.
+    excluded: dict[str, dict[str, Any]] = {}
+    for title, excl in (excluded_titles or {}).items():
+        title_n = require_canonical_title(title)
+        payload = dict(excl)
+        payload.setdefault("title", title_n)
+        excluded[title_n] = payload
+
+    missing = [require_canonical_title(t) for t in (missing_titles or ())]
+
+    return {
+        "schema_version": FIXTURE_SCHEMA_VERSION,
+        "catalog_schema_version": SCHEMA_VERSION,
+        "fixture_id": DEFAULT_FIXTURE_ID
+        if canonical == DEFAULT_APPROVED_RELEASE_POINT
+        else f"uscode-catalog-{canonical.replace('/', '-')}",
+        "expected_title_count": EXPECTED_TITLE_COUNT,
+        "canonical_titles": list(CANONICAL_USCODE_TITLES),
+        "currentness_disclaimer": CURRENTNESS_DISCLAIMER,
+        "notes": (
+            "Compact all-title release catalog recipe (USCIR-005). "
+            "Resolves one approved exact release, enumerates all expected title "
+            "packages, binds checksum + release point per package, and supports "
+            "deterministic resume. Expand via expand_catalog_fixture()."
+        ),
+        "proposed_release": {
+            "role": ReleasePointRole.PROPOSED_LATEST.value,
+            "release_point": canonical,
+            "provider": DEFAULT_PROVIDER_OLRC,
+            "congress": congress_s,
+            "release": release_s,
+            "discovered_at": discovered_at,
+            "discovery_source": USHOUSE_DOWNLOAD_PAGE,
+            "edition": f"olrc-proposed-{canonical.replace('/', '-')}",
+            "notes": (
+                "Catalog scrape candidate from the House OLRC download page; "
+                "not final provenance."
+            ),
+        },
+        "approved_release": {
+            "role": ReleasePointRole.APPROVED_EXACT.value,
+            "release_point": canonical,
+            "provider": DEFAULT_PROVIDER_OLRC,
+            "congress": congress_s,
+            "release": release_s,
+            "approved_by": approved_by,
+            "approved_at": approved_at,
+            "edition": f"olrc-{canonical.replace('/', '-')}",
+            "notes": "Human-sealed exact release point for all-title catalog admission.",
+        },
+        "approved_mixed_overrides": {},
+        "generators": {
+            "title_package": {
+                "provider": DEFAULT_PROVIDER_OLRC,
+                "format_kind": "xml",
+                "status": TitlePackageStatus.VERIFIED.value,
+                "verification": VerificationResult.VERIFIED.value,
+                "acquired_at": acquired_at,
+                "media_type": "application/zip",
+                "checksum_seed_template": "{provider}|{release_point}|title-{title}|package",
+                "source_url_template": (
+                    "https://uscode.house.gov/download/releasepoints/us/pl/"
+                    "{congress}/{release}/xml_usc{title_code}@{congress}-{release}.zip"
+                ),
+            },
+            "resume_receipt": {
+                "checkpoint_seq_start": 1,
+            },
+        },
+        "excluded_packages": excluded,
+        "missing_titles": missing,
+        "seed_overrides": {},
+        "sample_exclusions": [
+            {
+                "kind": ExclusionKind.CLASSIFICATION_GAP.value,
+                "title": "35",
+                "citation": "Pub. L. 117-328 div. W",
+                "public_law": "Pub. L. 117-328",
+                "reason": (
+                    "Classification table records a pending editorial "
+                    "reclassification affecting cross-references in Title 35; "
+                    "package itself remains admitted."
+                ),
+            }
+        ],
+    }
+
+
+def expand_catalog_fixture(payload: JsonMapping) -> dict[str, Any]:
+    """Expand a compact catalog recipe into structured catalog state.
+
+    Returns a mapping with keys:
+      ``approved_release``, ``proposed_release``, ``expected_packages``,
+      ``packages`` (fixture acquisitions), ``resume_receipts``,
+      ``excluded_packages``, ``missing_titles``, ``fixture_id``, etc.
+    """
+
+    if not isinstance(payload, Mapping):
+        raise CatalogFixtureSchemaError("fixture root must be a mapping")
+    schema = payload.get("schema_version")
+    if schema != FIXTURE_SCHEMA_VERSION:
+        raise CatalogFixtureSchemaError(
+            f"unsupported fixture schema_version {schema!r}; "
+            f"expected {FIXTURE_SCHEMA_VERSION!r}"
+        )
+
+    expected = int(payload.get("expected_title_count") or EXPECTED_TITLE_COUNT)
+    titles_list = payload.get("canonical_titles") or list(CANONICAL_USCODE_TITLES)
+    if len(titles_list) != expected:
+        raise CatalogFixtureSchemaError(
+            f"canonical_titles length {len(titles_list)} != expected_title_count {expected}"
+        )
+
+    proposed_raw = payload.get("proposed_release")
+    proposed = (
+        None if proposed_raw is None else ProposedReleasePoint.from_dict(proposed_raw)
+    )
+    approved = require_approved_exact(
+        payload.get("approved_release") or payload.get("approved")
+    )
+
+    gen = payload.get("generators") or {}
+    pkg_gen = gen.get("title_package") or gen.get("title_provenance") or {}
+    receipt_gen = gen.get("resume_receipt") or {}
+    seq_start = int(receipt_gen.get("checkpoint_seq_start", 1))
+
+    provider = SourceProvider.coerce(
+        pkg_gen.get("provider") or approved.provider
+    ).canonical()
+    format_kind = str(pkg_gen.get("format_kind") or "xml")
+    acquired_at = pkg_gen.get("acquired_at") or DEFAULT_ACQUIRED_AT
+    status = TitlePackageStatus.coerce(
+        pkg_gen.get("status") or TitlePackageStatus.VERIFIED
+    )
+    verification = VerificationResult.coerce(
+        pkg_gen.get("verification") or VerificationResult.VERIFIED
+    )
+
+    seed_overrides = payload.get("seed_overrides") or {}
+    excluded_packages_raw = payload.get("excluded_packages") or {}
+    missing_titles = {
+        require_canonical_title(t) for t in (payload.get("missing_titles") or ())
+    }
+    inline_packages = payload.get("packages") or {}
+    inline_receipts = payload.get("resume_receipts") or {}
+    inline_specs = payload.get("expected_packages") or {}
+
+    congress = approved.congress or DEFAULT_APPROVED_CONGRESS
+    release = approved.release or DEFAULT_APPROVED_RELEASE
+
+    expected_packages: dict[str, TitlePackageSpec] = {}
+    packages: dict[str, TitlePackageAcquisition] = {}
+    receipts: dict[str, TitleResumeReceipt] = {}
+    excluded_map: dict[str, TitleExclusion] = {}
+
+    for index, title in enumerate(titles_list):
+        title_n = require_canonical_title(title)
+        override = seed_overrides.get(title_n) or {}
+        rp = str(override.get("release_point") or approved.release_point)
+        if not rp.upper().startswith("USCODE-"):
+            rp, _, _ = parse_release_point_id(rp)
+
+        checksum = str(
+            override.get("content_sha256")
+            or override.get("expected_sha256")
+            or expected_title_package_sha256(
+                release_point=rp, title=title_n, provider=provider
+            )
+        )
+        package_id = str(override.get("package_id") or rp)
+        source_url = str(
+            override.get("source_url")
+            or ushouse_releasepoint_zip_url(
+                congress=congress,
+                release=release,
+                title=title_n,
+                format_kind=format_kind,
+            )
+        )
+
+        excl_raw = excluded_packages_raw.get(title_n) or override.get("exclusion")
+        exclusion: Optional[TitleExclusion] = None
+        if excl_raw is not None:
+            if isinstance(excl_raw, TitleExclusion):
+                exclusion = excl_raw
+            elif isinstance(excl_raw, Mapping):
+                excl_payload = dict(excl_raw)
+                excl_payload.setdefault("title", title_n)
+                exclusion = TitleExclusion.from_dict(excl_payload)
+            else:
+                raise CatalogFixtureSchemaError(
+                    f"excluded_packages[{title_n!r}] must be a mapping"
+                )
+            excluded_map[title_n] = exclusion
+
+        if title_n in inline_specs:
+            spec = TitlePackageSpec.from_dict(inline_specs[title_n])
+        else:
+            spec = TitlePackageSpec(
+                title=title_n,
+                release_point=rp,
+                package_id=package_id,
+                source_url=source_url,
+                expected_sha256=checksum,
+                provider=provider,
+                format_kind=str(override.get("format_kind") or format_kind),
+                required=title_n not in missing_titles,
+                exclusion=exclusion,
+                metadata=override.get("metadata") or {},
+            )
+        expected_packages[title_n] = spec
+
+        if title_n in missing_titles:
+            packages[title_n] = TitlePackageAcquisition(
+                title=title_n,
+                disposition=PackageDisposition.MISSING,
+                release_point=None,
+                content_sha256=None,
+                package_id=None,
+                source_url=source_url,
+                status=TitlePackageStatus.FAILED,
+                verification=VerificationResult.MISSING,
+                notes=f"title {title_n} package missing from catalog fixture",
+                metadata={"fixture_missing": True},
+            )
+            continue
+
+        if title_n in inline_packages:
+            pkg = TitlePackageAcquisition.from_dict(inline_packages[title_n])
+            packages[title_n] = pkg
+            if pkg.resume_receipt is not None:
+                receipts[title_n] = pkg.resume_receipt
+            continue
+
+        if exclusion is not None:
+            prov = TitlePackageProvenance(
+                title=title_n,
+                release_point=rp,
+                provider=provider,
+                package_id=package_id,
+                source_url=source_url,
+                content_sha256=checksum,
+                acquired_at=override.get("acquired_at") or acquired_at,
+                verification=VerificationResult.MISSING,
+                status=TitlePackageStatus.EXCLUDED,
+                format_kind=format_kind,
+                exclusion=exclusion,
+                notes=exclusion.reason,
+                metadata=override.get("metadata") or {},
+            )
+            receipt = TitleResumeReceipt(
+                title=title_n,
+                release_point=rp,
+                package_id=package_id,
+                content_sha256=checksum,
+                status=TitlePackageStatus.EXCLUDED,
+                verification=VerificationResult.MISSING,
+                source_url=source_url,
+                acquired_at=prov.acquired_at,
+                checkpoint_seq=seq_start + index,
+                provider=provider,
+                notes=exclusion.reason,
+                metadata={"schema_version": SCHEMA_VERSION, "format_kind": format_kind},
+            )
+            packages[title_n] = TitlePackageAcquisition(
+                title=title_n,
+                disposition=PackageDisposition.EXCLUDED,
+                release_point=rp,
+                content_sha256=checksum,
+                package_id=package_id,
+                source_url=source_url,
+                status=TitlePackageStatus.EXCLUDED,
+                verification=VerificationResult.MISSING,
+                provenance=prov,
+                resume_receipt=receipt,
+                exclusion=exclusion,
+                redownloaded=False,
+                notes=exclusion.reason,
+            )
+            receipts[title_n] = receipt
+            continue
+
+        # Default admitted package: verified with bound checksum + release point.
+        pkg_status = TitlePackageStatus.coerce(override.get("status") or status)
+        pkg_verification = VerificationResult.coerce(
+            override.get("verification") or verification
+        )
+        prov = TitlePackageProvenance(
+            title=title_n,
+            release_point=rp,
+            provider=provider,
+            package_id=package_id,
+            source_url=source_url,
+            content_sha256=checksum,
+            acquired_at=override.get("acquired_at") or acquired_at,
+            verification=pkg_verification,
+            status=pkg_status,
+            media_type=str(override.get("media_type") or "application/zip"),
+            byte_size=override.get("byte_size"),
+            format_kind=str(override.get("format_kind") or format_kind),
+            notes=override.get("notes"),
+            metadata=override.get("metadata") or {},
+        )
+        if title_n in inline_receipts:
+            receipt = TitleResumeReceipt.from_dict(inline_receipts[title_n])
+        else:
+            receipt = TitleResumeReceipt(
+                title=title_n,
+                release_point=rp,
+                package_id=package_id,
+                content_sha256=checksum,
+                status=pkg_status,
+                verification=pkg_verification,
+                source_url=source_url,
+                acquired_at=prov.acquired_at,
+                checkpoint_seq=seq_start + index,
+                provider=provider,
+                notes=prov.notes,
+                metadata={"schema_version": SCHEMA_VERSION, "format_kind": prov.format_kind},
+            )
+        packages[title_n] = TitlePackageAcquisition(
+            title=title_n,
+            disposition=PackageDisposition.ACCEPTED,
+            release_point=rp,
+            content_sha256=checksum,
+            package_id=package_id,
+            source_url=source_url,
+            status=pkg_status,
+            verification=pkg_verification,
+            provenance=prov,
+            resume_receipt=receipt,
+            redownloaded=True,  # first acquisition counts as a download
+            notes=prov.notes,
+            metadata={"fixture_id": payload.get("fixture_id"), "acquired_from": "fixture"},
+        )
+        receipts[title_n] = receipt
+
+    return {
+        "approved_release": approved,
+        "proposed_release": proposed,
+        "expected_packages": expected_packages,
+        "packages": packages,
+        "resume_receipts": receipts,
+        "excluded_packages": excluded_map,
+        "missing_titles": tuple(sorted(missing_titles)),
+        "canonical_titles": tuple(require_canonical_title(t) for t in titles_list),
+        "expected_title_count": expected,
+        "fixture_id": payload.get("fixture_id"),
+        "currentness_disclaimer": str(
+            payload.get("currentness_disclaimer") or CURRENTNESS_DISCLAIMER
+        ),
+        "notes": payload.get("notes"),
+        "sample_exclusions": payload.get("sample_exclusions") or [],
+        "approved_mixed_overrides": payload.get("approved_mixed_overrides") or {},
+        "schema_version": SCHEMA_VERSION,
+        "fixture_schema_version": FIXTURE_SCHEMA_VERSION,
+        "metadata": {
+            "fixture_id": payload.get("fixture_id"),
+            "sample_exclusions": payload.get("sample_exclusions") or [],
+        },
+    }
+
+
+def load_catalog_fixture_payload(path: PathLike | None = None) -> dict[str, Any]:
+    """Load the sealed compact catalog fixture recipe from disk."""
+
+    p = Path(path) if path is not None else default_catalog_fixture_path()
+    with p.open("r", encoding="utf-8") as handle:
+        payload = json.load(handle)
+    if not isinstance(payload, Mapping):
+        raise CatalogFixtureSchemaError(f"fixture root must be a mapping: {p}")
+    return dict(payload)
+
+
+def load_catalog_fixture(path: PathLike | None = None) -> dict[str, Any]:
+    """Load and expand the sealed all-title release-catalog fixture."""
+
+    return expand_catalog_fixture(load_catalog_fixture_payload(path))
+
+
+def write_default_catalog_fixture(path: PathLike | None = None) -> Path:
+    """Materialize the compact default catalog fixture recipe."""
+
+    p = Path(path) if path is not None else default_catalog_fixture_path()
+    p.parent.mkdir(parents=True, exist_ok=True)
+    payload = build_default_catalog_fixture_payload()
+    p.write_text(
+        json.dumps(payload, indent=2, sort_keys=True, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+    return p
+
+
+# ---------------------------------------------------------------------------
+# Checkpoint helpers
+# ---------------------------------------------------------------------------
+
+
+def _atomic_write_json(path: Path, payload: Mapping[str, Any]) -> None:
+    """Write JSON atomically (temp file + os.replace)."""
+
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    text = json.dumps(payload, indent=2, sort_keys=True, ensure_ascii=False) + "\n"
+    fd, tmp_name = tempfile.mkstemp(
+        prefix=f".{path.name}.",
+        suffix=".tmp",
+        dir=str(path.parent),
+    )
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(text)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(tmp_name, path)
+    except Exception:
+        try:
+            os.unlink(tmp_name)
+        except OSError:
+            pass
+        raise
+
+
+def default_checkpoint_directory() -> Path:
+    """Return the preferred catalog checkpoint directory.
+
+    Prefers ``$IPFS_ACCELERATE_AGENT_TASK_CHECKPOINT_DIR`` when set, otherwise
+    a local ``.uscode_release_catalog_checkpoints`` directory under cwd.
+    """
+
+    env = os.environ.get("IPFS_ACCELERATE_AGENT_TASK_CHECKPOINT_DIR")
+    if env:
+        return Path(env)
+    return Path.cwd() / ".uscode_release_catalog_checkpoints"
+
+
+# ---------------------------------------------------------------------------
+# Catalog engine
+# ---------------------------------------------------------------------------
+
+
+class UscodeReleaseCatalog:
+    """Exact all-title release catalog for the sealed US Code baseline.
+
+    Resolves one approved release, enumerates expected title packages,
+    acquires packages from sealed fixtures (network opt-in is out of scope
+    for unit tests), checkpoints resume receipts, and reports missing or
+    excluded packages.
+    """
+
+    def __init__(
+        self,
+        *,
+        policy: Optional[UscodeSourcePolicy] = None,
+        fixture_path: PathLike | None = None,
+        checkpoint_dir: PathLike | None = None,
+        required_titles: Sequence[str] = CANONICAL_USCODE_TITLES,
+        allow_network: bool = False,
+    ) -> None:
+        self._policy = policy if policy is not None else UscodeSourcePolicy(
+            required_titles=required_titles
+        )
+        self.fixture_path = (
+            Path(fixture_path) if fixture_path is not None else default_catalog_fixture_path()
+        )
+        self.checkpoint_dir = (
+            Path(checkpoint_dir)
+            if checkpoint_dir is not None
+            else default_checkpoint_directory()
+        )
+        self._required_titles: tuple[str, ...] = tuple(
+            require_canonical_title(t) for t in required_titles
+        )
+        self.allow_network = bool(allow_network)
+        self._last_result: Optional[CatalogAcquisitionResult] = None
+        self._expected_packages: dict[str, TitlePackageSpec] = {}
+        self._packages: dict[str, TitlePackageAcquisition] = {}
+        self._receipts: dict[str, TitleResumeReceipt] = {}
+        self._fixture_state: Optional[dict[str, Any]] = None
+
+    # -- properties --------------------------------------------------------
+
+    @property
+    def policy(self) -> UscodeSourcePolicy:
+        return self._policy
+
+    @property
+    def required_titles(self) -> tuple[str, ...]:
+        return self._required_titles
+
+    @property
+    def last_result(self) -> Optional[CatalogAcquisitionResult]:
+        return self._last_result
+
+    @property
+    def expected_packages(self) -> Mapping[str, TitlePackageSpec]:
+        return dict(self._expected_packages)
+
+    @property
+    def packages(self) -> Mapping[str, TitlePackageAcquisition]:
+        return dict(self._packages)
+
+    @property
+    def resume_receipts(self) -> Mapping[str, TitleResumeReceipt]:
+        return dict(self._receipts)
+
+    # -- release resolution ------------------------------------------------
+
+    def resolve_approved_release(
+        self,
+        *,
+        release_point: Any | None = None,
+        approved_by: str = DEFAULT_CATALOG_APPROVED_BY,
+        approved_at: Any = DEFAULT_APPROVED_AT,
+        provider: SourceProvider | str = SourceProvider.OLRC_HOUSE,
+        edition: Optional[str] = None,
+        notes: Optional[str] = None,
+        from_fixture: bool = False,
+    ) -> ApprovedReleasePoint:
+        """Resolve and seal one approved exact release point for the catalog.
+
+        When *from_fixture* is True, the approved release is taken from the
+        sealed catalog fixture. Proposed-latest discovery alone is never
+        admitted as final provenance.
+        """
+
+        if from_fixture:
+            state = self._ensure_fixture_state()
+            approved = state["approved_release"]
+            proposed = state.get("proposed_release")
+            if proposed is not None:
+                self._policy.propose_latest_from_discovery(
+                    release_point=proposed.release_point,
+                    provider=proposed.provider,
+                    discovered_at=proposed.discovered_at,
+                    discovery_source=proposed.discovery_source,
+                    edition=proposed.edition,
+                    notes=proposed.notes,
+                )
+            self._policy.approve_exact_release(
+                approved,
+                approved_by=approved.approved_by,
+                approved_at=approved.approved_at,
+                edition=approved.edition,
+                notes=approved.notes,
+            )
+            for title, alt in (state.get("approved_mixed_overrides") or {}).items():
+                self._policy.approve_mixed_override(title, alt)
+            return self._policy.require_approved()
+
+        if release_point is None:
+            if self._policy.approved_release is not None:
+                return self._policy.require_approved()
+            raise MissingApprovedReleaseError(
+                "no approved exact release point; supply release_point or from_fixture=True"
+            )
+
+        # Reject hard-coded latest before approval.
+        if isinstance(release_point, str):
+            try:
+                parse_release_point_id(release_point)
+            except HardCodedLatestEditionError:
+                raise
+            except UscodeSourcePolicyError:
+                # Allow govinfo-style package ids through approve_exact_release.
+                pass
+
+        if isinstance(release_point, ProposedReleasePoint):
+            self._policy._proposed = release_point  # record discovery
+            return self._policy.approve_exact_release(
+                release_point,
+                approved_by=approved_by,
+                approved_at=approved_at,
+                provider=provider,
+                edition=edition,
+                notes=notes,
+            )
+
+        return self._policy.approve_exact_release(
+            release_point,
+            approved_by=approved_by,
+            approved_at=approved_at,
+            provider=provider,
+            edition=edition,
+            notes=notes,
+        )
+
+    def propose_latest_from_discovery(
+        self,
+        *,
+        release_point: Any,
+        provider: SourceProvider | str = SourceProvider.OLRC_HOUSE,
+        discovered_at: Any = DEFAULT_DISCOVERED_AT,
+        discovery_source: str = USHOUSE_DOWNLOAD_PAGE,
+        edition: Optional[str] = None,
+        notes: Optional[str] = None,
+    ) -> ProposedReleasePoint:
+        """Record a discovery-only proposed release (not final provenance)."""
+
+        return self._policy.propose_latest_from_discovery(
+            release_point=release_point,
+            provider=provider,
+            discovered_at=discovered_at,
+            discovery_source=discovery_source,
+            edition=edition,
+            notes=notes,
+        )
+
+    # -- package enumeration -----------------------------------------------
+
+    def enumerate_expected_packages(
+        self,
+        *,
+        format_kind: str = "xml",
+        from_fixture: bool = False,
+    ) -> dict[str, TitlePackageSpec]:
+        """Enumerate every expected title package under the approved release."""
+
+        if from_fixture:
+            state = self._ensure_fixture_state()
+            self._expected_packages = dict(state["expected_packages"])
+            return dict(self._expected_packages)
+
+        approved = self._policy.require_approved()
+        specs: dict[str, TitlePackageSpec] = {}
+        for title in self._required_titles:
+            rp = self._policy.expected_release_for_title(title)
+            if not str(rp).upper().startswith("USCODE-"):
+                rp_n, congress, release = parse_release_point_id(rp)
+            else:
+                rp_n = rp
+                congress = approved.congress or DEFAULT_APPROVED_CONGRESS
+                release = approved.release or DEFAULT_APPROVED_RELEASE
+            provider = approved.provider
+            checksum = expected_title_package_sha256(
+                release_point=rp_n, title=title, provider=provider
+            )
+            source_url = ushouse_releasepoint_zip_url(
+                congress=congress or approved.congress or DEFAULT_APPROVED_CONGRESS,
+                release=release or approved.release or DEFAULT_APPROVED_RELEASE,
+                title=title,
+                format_kind=format_kind,
+            )
+            specs[title] = TitlePackageSpec(
+                title=title,
+                release_point=rp_n,
+                package_id=rp_n,
+                source_url=source_url,
+                expected_sha256=checksum,
+                provider=provider,
+                format_kind=format_kind,
+                required=True,
+            )
+        self._expected_packages = specs
+        return dict(specs)
+
+    # -- fixture acquisition -----------------------------------------------
+
+    def _ensure_fixture_state(self) -> dict[str, Any]:
+        if self._fixture_state is None:
+            self._fixture_state = load_catalog_fixture(self.fixture_path)
+        return self._fixture_state
+
+    def load_fixture(self, path: PathLike | None = None) -> dict[str, Any]:
+        """Load and expand a catalog fixture, updating fixture_path when given."""
+
+        if path is not None:
+            self.fixture_path = Path(path)
+            self._fixture_state = None
+        state = self._ensure_fixture_state()
+        return state
+
+    def acquire_from_fixture(
+        self,
+        path: PathLike | None = None,
+        *,
+        checkpoint: bool = True,
+        require_complete: bool = False,
+    ) -> CatalogAcquisitionResult:
+        """Acquire all title packages deterministically from a sealed fixture.
+
+        Every accepted package binds ``content_sha256`` and ``release_point``.
+        Title completeness is reported explicitly (missing/excluded listed).
+        """
+
+        if path is not None:
+            self.fixture_path = Path(path)
+            self._fixture_state = None
+
+        state = self._ensure_fixture_state()
+        approved = self.resolve_approved_release(from_fixture=True)
+        expected = self.enumerate_expected_packages(from_fixture=True)
+
+        packages: dict[str, TitlePackageAcquisition] = {}
+        receipts: dict[str, TitleResumeReceipt] = {}
+        download_count = 0
+
+        for title in self._required_titles:
+            pkg = state["packages"].get(title)
+            if pkg is None:
+                packages[title] = TitlePackageAcquisition(
+                    title=title,
+                    disposition=PackageDisposition.MISSING,
+                    release_point=None,
+                    content_sha256=None,
+                    status=TitlePackageStatus.FAILED,
+                    verification=VerificationResult.MISSING,
+                    notes=f"title {title} absent from fixture expansion",
+                )
+                continue
+
+            # Re-validate accepted packages bind checksum + release point.
+            if pkg.disposition is PackageDisposition.ACCEPTED:
+                if not pkg.content_sha256 or not pkg.release_point:
+                    raise CatalogAcquisitionError(
+                        f"fixture package for title {title} missing checksum or release_point"
+                    )
+                # Admit into policy for mixed-vintage checks.
+                if pkg.provenance is not None:
+                    self._policy.record_title_provenance(
+                        pkg.provenance, build_receipt=False
+                    )
+                download_count += 1 if pkg.redownloaded else 0
+            elif pkg.disposition is PackageDisposition.EXCLUDED:
+                if pkg.provenance is not None:
+                    self._policy.record_title_provenance(
+                        pkg.provenance, build_receipt=False
+                    )
+
+            packages[title] = pkg
+            if pkg.resume_receipt is not None:
+                receipts[title] = pkg.resume_receipt
+                self._receipts[title] = pkg.resume_receipt
+            self._packages[title] = pkg
+
+        # Ensure every expected title has an entry (explicit completeness).
+        for title in self._required_titles:
+            if title not in packages:
+                packages[title] = TitlePackageAcquisition(
+                    title=title,
+                    disposition=PackageDisposition.MISSING,
+                    release_point=None,
+                    content_sha256=None,
+                    status=TitlePackageStatus.FAILED,
+                    verification=VerificationResult.MISSING,
+                    notes=f"title {title} not enumerated in acquisition",
+                )
+
+        completeness = build_completeness_report(
+            packages,
+            expected_titles=self._required_titles,
+            notes="Fixture acquisition completeness",
+            metadata={"mode": CatalogAcquisitionMode.FIXTURE.value},
+        )
+        if require_complete and not completeness.is_complete:
+            raise CatalogCompletenessError(
+                "catalog acquisition incomplete: "
+                f"missing={list(completeness.missing_titles)} "
+                f"failed={list(completeness.failed_titles)}"
+            )
+
+        result = CatalogAcquisitionResult(
+            approved_release=approved,
+            packages=packages,
+            completeness=completeness,
+            mode=CatalogAcquisitionMode.FIXTURE,
+            resume_receipts=receipts,
+            proposed_release=state.get("proposed_release"),
+            expected_packages=expected,
+            currentness_disclaimer=state.get(
+                "currentness_disclaimer", CURRENTNESS_DISCLAIMER
+            ),
+            schema_version=SCHEMA_VERSION,
+            fixture_id=state.get("fixture_id"),
+            notes=state.get("notes"),
+            metadata={
+                "fixture_schema_version": FIXTURE_SCHEMA_VERSION,
+                "sample_exclusions": state.get("sample_exclusions") or [],
+            },
+            download_count=download_count,
+            skip_count=0,
+        )
+        self._last_result = result
+
+        if checkpoint:
+            self.checkpoint_receipts(result)
+
+        return result
+
+    def acquire_title_from_fixture(
+        self,
+        title: Any,
+        *,
+        path: PathLike | None = None,
+    ) -> TitlePackageAcquisition:
+        """Acquire a single title package from the sealed fixture."""
+
+        title_n = require_canonical_title(title)
+        if path is not None or self._fixture_state is None:
+            self.load_fixture(path)
+        state = self._ensure_fixture_state()
+        if self._policy.approved_release is None:
+            self.resolve_approved_release(from_fixture=True)
+        pkg = state["packages"].get(title_n)
+        if pkg is None:
+            acq = TitlePackageAcquisition(
+                title=title_n,
+                disposition=PackageDisposition.MISSING,
+                release_point=None,
+                content_sha256=None,
+                status=TitlePackageStatus.FAILED,
+                verification=VerificationResult.MISSING,
+                notes=f"title {title_n} absent from fixture",
+            )
+        else:
+            acq = pkg
+            if acq.provenance is not None and acq.disposition in {
+                PackageDisposition.ACCEPTED,
+                PackageDisposition.EXCLUDED,
+            }:
+                self._policy.record_title_provenance(acq.provenance, build_receipt=False)
+            if acq.resume_receipt is not None:
+                self._receipts[title_n] = acq.resume_receipt
+        self._packages[title_n] = acq
+        return acq
+
+    # -- resume ------------------------------------------------------------
+
+    def resume(
+        self,
+        *,
+        prior: CatalogAcquisitionResult | Mapping[str, Any] | None = None,
+        checkpoint_path: PathLike | None = None,
+        on_disk_checksums: Optional[Mapping[str, str]] = None,
+        redownload_missing: bool = True,
+        require_complete: bool = False,
+    ) -> CatalogAcquisitionResult:
+        """Resume catalog acquisition without redownloading verified packages.
+
+        For each title with a verified resume receipt whose on-disk checksum
+        still matches (or is trusted when no on-disk hash is supplied), the
+        package is marked ``skipped_verified`` and is **not** redownloaded.
+        """
+
+        if prior is None and checkpoint_path is None:
+            # Fall back to last in-memory result or default checkpoint file.
+            if self._last_result is not None:
+                prior = self._last_result
+            else:
+                checkpoint_path = self.checkpoint_dir / "catalog_checkpoint.json"
+
+        if prior is None:
+            prior = self.load_checkpoint(checkpoint_path)
+
+        if isinstance(prior, Mapping):
+            # Accept either a full result or a checkpoint envelope.
+            if "packages" in prior and "approved_release" in prior:
+                prior_result = CatalogAcquisitionResult.from_dict(prior)
+            elif "result" in prior:
+                prior_result = CatalogAcquisitionResult.from_dict(prior["result"])
+            else:
+                raise CatalogCheckpointError(
+                    "checkpoint payload must contain packages/approved_release or result"
+                )
+        else:
+            prior_result = prior
+
+        approved = prior_result.approved_release
+        self._policy.approve_exact_release(
+            approved,
+            approved_by=approved.approved_by,
+            approved_at=approved.approved_at,
+            edition=approved.edition,
+            notes=approved.notes,
+        )
+        if prior_result.proposed_release is not None:
+            self._policy._proposed = prior_result.proposed_release
+
+        disk = {
+            require_canonical_title(t): str(h).lower()
+            for t, h in (on_disk_checksums or {}).items()
+        }
+        packages: dict[str, TitlePackageAcquisition] = {}
+        receipts: dict[str, TitleResumeReceipt] = {}
+        download_count = 0
+        skip_count = 0
+
+        # Ensure fixture state is available for redownload of non-verified titles.
+        fixture_packages: Mapping[str, TitlePackageAcquisition] = {}
+        if redownload_missing:
+            try:
+                fixture_packages = self._ensure_fixture_state()["packages"]
+            except (OSError, CatalogFixtureSchemaError, FileNotFoundError):
+                fixture_packages = {}
+
+        for title in self._required_titles:
+            prior_pkg = prior_result.packages.get(title)
+            prior_receipt = prior_result.resume_receipts.get(title)
+            if prior_receipt is None and prior_pkg is not None:
+                prior_receipt = prior_pkg.resume_receipt
+
+            if prior_receipt is not None and prior_receipt.is_verified:
+                on_disk = disk.get(title)
+                disposition_map = self._policy.resume_from_receipt(
+                    prior_receipt, on_disk_sha256=on_disk
+                )
+                if disposition_map["should_skip_redownload"]:
+                    # Reconstruct skipped acquisition from prior without redownload.
+                    base = prior_pkg
+                    packages[title] = TitlePackageAcquisition(
+                        title=title,
+                        disposition=PackageDisposition.SKIPPED_VERIFIED,
+                        release_point=prior_receipt.release_point,
+                        content_sha256=prior_receipt.content_sha256,
+                        package_id=prior_receipt.package_id,
+                        source_url=prior_receipt.source_url,
+                        status=TitlePackageStatus.VERIFIED,
+                        verification=VerificationResult.VERIFIED,
+                        provenance=None if base is None else base.provenance,
+                        resume_receipt=prior_receipt,
+                        redownloaded=False,
+                        notes="resume: verified package skipped (no redownload)",
+                        metadata={
+                            "resume_action": "skip",
+                            "receipt_digest": prior_receipt.receipt_digest,
+                        },
+                    )
+                    receipts[title] = prior_receipt
+                    skip_count += 1
+                    self._packages[title] = packages[title]
+                    self._receipts[title] = prior_receipt
+                    continue
+                # verify_failed or redownload: fall through to fixture re-acquire.
+
+            # Not verified / needs redownload — re-acquire from fixture if available.
+            if redownload_missing and title in fixture_packages:
+                fresh = fixture_packages[title]
+                if fresh.disposition is PackageDisposition.ACCEPTED:
+                    # Count as a redownload.
+                    packages[title] = TitlePackageAcquisition(
+                        title=title,
+                        disposition=PackageDisposition.ACCEPTED,
+                        release_point=fresh.release_point,
+                        content_sha256=fresh.content_sha256,
+                        package_id=fresh.package_id,
+                        source_url=fresh.source_url,
+                        status=fresh.status,
+                        verification=fresh.verification,
+                        provenance=fresh.provenance,
+                        resume_receipt=fresh.resume_receipt,
+                        exclusion=fresh.exclusion,
+                        redownloaded=True,
+                        notes="resume: redownloaded from fixture",
+                        metadata={"resume_action": "redownload"},
+                    )
+                    download_count += 1
+                    if fresh.resume_receipt is not None:
+                        receipts[title] = fresh.resume_receipt
+                        self._receipts[title] = fresh.resume_receipt
+                else:
+                    packages[title] = fresh
+                    if fresh.resume_receipt is not None:
+                        receipts[title] = fresh.resume_receipt
+                self._packages[title] = packages[title]
+                continue
+
+            if prior_pkg is not None:
+                packages[title] = prior_pkg
+                if prior_receipt is not None:
+                    receipts[title] = prior_receipt
+                self._packages[title] = packages[title]
+            else:
+                packages[title] = TitlePackageAcquisition(
+                    title=title,
+                    disposition=PackageDisposition.MISSING,
+                    release_point=None,
+                    content_sha256=None,
+                    status=TitlePackageStatus.FAILED,
+                    verification=VerificationResult.MISSING,
+                    notes="resume: no prior package and no fixture redownload",
+                )
+                self._packages[title] = packages[title]
+
+        expected = prior_result.expected_packages or self.enumerate_expected_packages(
+            from_fixture=bool(fixture_packages)
+        )
+        completeness = build_completeness_report(
+            packages,
+            expected_titles=self._required_titles,
+            notes="Resume acquisition completeness",
+            metadata={"mode": CatalogAcquisitionMode.RESUME.value},
+        )
+        if require_complete and not completeness.is_complete:
+            raise CatalogCompletenessError(
+                "catalog resume incomplete: "
+                f"missing={list(completeness.missing_titles)} "
+                f"failed={list(completeness.failed_titles)}"
+            )
+
+        result = CatalogAcquisitionResult(
+            approved_release=approved,
+            packages=packages,
+            completeness=completeness,
+            mode=CatalogAcquisitionMode.RESUME,
+            resume_receipts=receipts,
+            proposed_release=prior_result.proposed_release,
+            expected_packages=expected,
+            currentness_disclaimer=prior_result.currentness_disclaimer,
+            schema_version=SCHEMA_VERSION,
+            fixture_id=prior_result.fixture_id,
+            notes="Resumed catalog acquisition; verified packages not redownloaded",
+            metadata={
+                "prior_mode": prior_result.mode.value,
+                "prior_download_count": prior_result.download_count,
+            },
+            download_count=download_count,
+            skip_count=skip_count,
+        )
+        self._last_result = result
+        self.checkpoint_receipts(result)
+        return result
+
+    # -- completeness ------------------------------------------------------
+
+    def completeness_report(
+        self,
+        packages: Mapping[str, TitlePackageAcquisition] | None = None,
+        *,
+        require_complete: bool = False,
+    ) -> TitleCompletenessReport:
+        """Return an explicit title completeness report."""
+
+        if packages is None:
+            if self._last_result is not None:
+                packages = self._last_result.packages
+            else:
+                packages = self._packages
+        report = build_completeness_report(
+            packages, expected_titles=self._required_titles
+        )
+        if require_complete and not report.is_complete:
+            raise CatalogCompletenessError(
+                "title completeness failed: "
+                f"missing={list(report.missing_titles)} "
+                f"failed={list(report.failed_titles)} "
+                f"excluded={list(report.excluded_titles)}"
+            )
+        return report
+
+    def report_missing_and_excluded(
+        self,
+        packages: Mapping[str, TitlePackageAcquisition] | None = None,
+    ) -> dict[str, tuple[str, ...]]:
+        """Return ``{"missing": (...), "excluded": (...)}`` title lists."""
+
+        report = self.completeness_report(packages)
+        return {
+            "missing": report.missing_titles,
+            "excluded": report.excluded_titles,
+            "failed": report.failed_titles,
+        }
+
+    # -- checkpoints -------------------------------------------------------
+
+    def checkpoint_path(self, name: str = "catalog_checkpoint.json") -> Path:
+        return Path(self.checkpoint_dir) / name
+
+    def checkpoint_receipts(
+        self,
+        result: CatalogAcquisitionResult | None = None,
+        *,
+        path: PathLike | None = None,
+    ) -> Path:
+        """Atomically write resume receipts and acquisition result to disk."""
+
+        if result is None:
+            if self._last_result is None:
+                raise CatalogCheckpointError("no acquisition result to checkpoint")
+            result = self._last_result
+
+        target = Path(path) if path is not None else self.checkpoint_path()
+        envelope = {
+            "schema_version": SCHEMA_VERSION,
+            "checkpoint_kind": "uscode-release-catalog",
+            "approved_release": result.approved_release.to_dict(),
+            "completeness": result.completeness.to_dict(),
+            "download_count": result.download_count,
+            "skip_count": result.skip_count,
+            "fixture_id": result.fixture_id,
+            "mode": result.mode.value,
+            "resume_receipts": {
+                k: v.to_dict()
+                for k, v in sorted(result.resume_receipts.items(), key=lambda kv: kv[0])
+            },
+            "packages": {
+                k: {
+                    "title": v.title,
+                    "disposition": v.disposition.value,
+                    "release_point": v.release_point,
+                    "content_sha256": v.content_sha256,
+                    "package_id": v.package_id,
+                    "source_url": v.source_url,
+                    "status": v.status.value,
+                    "verification": v.verification.value,
+                    "redownloaded": v.redownloaded,
+                    "resume_receipt": (
+                        None if v.resume_receipt is None else v.resume_receipt.to_dict()
+                    ),
+                    "exclusion": None if v.exclusion is None else v.exclusion.to_dict(),
+                    "notes": v.notes,
+                }
+                for k, v in sorted(result.packages.items(), key=lambda kv: kv[0])
+            },
+            "result": result.to_dict(),
+            "result_digest": result.result_digest(),
+        }
+        _atomic_write_json(target, envelope)
+        return target
+
+    def load_checkpoint(self, path: PathLike | None = None) -> CatalogAcquisitionResult:
+        """Load a previously written catalog checkpoint."""
+
+        target = Path(path) if path is not None else self.checkpoint_path()
+        if not target.is_file():
+            raise CatalogCheckpointError(f"checkpoint not found: {target}")
+        with target.open("r", encoding="utf-8") as handle:
+            payload = json.load(handle)
+        if not isinstance(payload, Mapping):
+            raise CatalogCheckpointError(f"checkpoint root must be a mapping: {target}")
+        if "result" in payload:
+            return CatalogAcquisitionResult.from_dict(payload["result"])
+        return CatalogAcquisitionResult.from_dict(payload)
+
+    # -- binding validation ------------------------------------------------
+
+    def assert_accepted_packages_bound(
+        self,
+        packages: Mapping[str, TitlePackageAcquisition] | None = None,
+    ) -> None:
+        """Fail closed when any accepted package lacks checksum or release point."""
+
+        if packages is None:
+            packages = self._packages if self._packages else (
+                self._last_result.packages if self._last_result else {}
+            )
+        for title, pkg in packages.items():
+            if pkg.disposition in {
+                PackageDisposition.ACCEPTED,
+                PackageDisposition.SKIPPED_VERIFIED,
+            }:
+                if not pkg.content_sha256:
+                    raise CatalogAcquisitionError(
+                        f"accepted package for title {title} missing content_sha256"
+                    )
+                if not pkg.release_point:
+                    raise CatalogAcquisitionError(
+                        f"accepted package for title {title} missing release_point"
+                    )
+
+
+__all__ = [
+    "CANONICAL_USCODE_TITLES",
+    "CURRENTNESS_DISCLAIMER",
+    "DEFAULT_APPROVED_RELEASE_POINT",
+    "DEFAULT_CATALOG_APPROVED_BY",
+    "DEFAULT_FIXTURE_ID",
+    "EXPECTED_TITLE_COUNT",
+    "FIXTURE_SCHEMA_VERSION",
+    "SCHEMA_VERSION",
+    "CatalogAcquisitionError",
+    "CatalogAcquisitionMode",
+    "CatalogAcquisitionResult",
+    "CatalogCheckpointError",
+    "CatalogCompletenessError",
+    "CatalogFixtureSchemaError",
+    "HardCodedLatestEditionError",
+    "MissingApprovedReleaseError",
+    "PackageDisposition",
+    "TitleCompletenessReport",
+    "TitlePackageAcquisition",
+    "TitlePackageSpec",
+    "UnapprovedMixedVintageError",
+    "UnapprovedProposedReleaseError",
+    "UscodeReleaseCatalog",
+    "UscodeReleaseCatalogError",
+    "UscodeSourcePolicy",
+    "build_completeness_report",
+    "build_default_catalog_fixture_payload",
+    "canonical_json_dumps",
+    "content_sha256",
+    "default_catalog_fixture_path",
+    "default_checkpoint_directory",
+    "digest_mapping",
+    "expand_catalog_fixture",
+    "expected_title_package_sha256",
+    "load_catalog_fixture",
+    "load_catalog_fixture_payload",
+    "normalize_title",
+    "parse_release_point_id",
+    "require_canonical_title",
+    "titles_missing_from_manifest",
+    "ushouse_releasepoint_zip_url",
+    "ushouse_title_code",
+    "write_default_catalog_fixture",
+]

scrapers_and_normalizers/ipfs_datasets_py/processors/legal_scrapers/federal_scrapers/uscode_release_processor.py

@@ -0,0 +1,1539 @@
+"""Title 35 U.S. Code release-point acquisition (PATLAW-013).
+
+Acquires exact House OLRC / GovInfo U.S. Code release points for Title 35
+(Patents), records USLM/XML/HTML/PDF identities and source receipts, and
+exposes uncodified / slip-law classification gaps instead of pretending the
+current codification is complete.
+
+Design invariants:
+
+* Edition identity is never the hard-coded token ``"latest"``; connectors
+  record concrete release-point / package identifiers.
+* Stable section identity is independent of source format (USLM, XML, HTML,
+  PDF): ``usc:{title}:{section}``.
+* Missing release-point data yields status ``unknown`` (fail-closed).
+* Official artifact identity and derived presentation identity remain
+  distinct via :mod:`patent_authority_sources`.
+* Live network I/O is opt-in; unit tests use recorded fixtures only.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from dataclasses import dataclass, field
+from datetime import date, datetime, timezone
+from enum import Enum
+from pathlib import Path
+from typing import Any, Iterable, Iterator, Mapping, MutableMapping, Optional, Sequence, Union
+
+from ipfs_datasets_py.processors.legal_data.patent_authority_sources import (
+    SCHEMA_VERSION as AUTHORITY_SCHEMA_VERSION,
+    AuthoritySourceRecord,
+    AuthoritySourceRegistry,
+    AuthorityTier,
+    ArtifactIdentity,
+    HardCodedLatestEditionError,
+    IdentityRole,
+    RetryCachePolicy,
+    SourceReceipt,
+    VerificationState,
+    canonical_json_dumps,
+    reject_hard_coded_latest,
+)
+
+SCHEMA_VERSION = "uscode-release-processor-v1"
+FIXTURE_SCHEMA_VERSION = "uscode-release-fixture-v1"
+
+DEFAULT_TITLE = "35"
+DEFAULT_JURISDICTION = "US"
+COLLECTION_USCODE = "USCODE"
+
+# Patent-sensitive Title 35 sections required by PATLAW-013 / privacy gate.
+CONFIDENTIALITY_SECTION = "122"
+SECRECY_ORDER_SECTIONS = tuple(str(n) for n in range(181, 189))  # 181–188 inclusive
+PATENT_SENSITIVE_SECTIONS = (CONFIDENTIALITY_SECTION, *SECRECY_ORDER_SECTIONS)
+
+USHOUSE_DOWNLOAD_PAGE = "https://uscode.house.gov/download/download.shtml"
+USHOUSE_RELEASEPOINT_BASE = "https://uscode.house.gov/download/releasepoints"
+GOVINFO_CONTENT_BASE = "https://www.govinfo.gov/content/pkg"
+
+_SECTION_TOKEN_RE = re.compile(
+    r"(?:§+\s*)?(?:sec(?:tion)?\.?\s*)?(?P<section>\d+[A-Za-z0-9.\-]*(?:\([a-zA-Z0-9]+\))*)",
+    re.IGNORECASE,
+)
+_RELEASE_POINT_RE = re.compile(
+    r"(?:us/pl/)?(?P<congress>\d+)(?:[/\-])(?P<release>[A-Za-z0-9]+)",
+    re.IGNORECASE,
+)
+_SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
+
+PathLike = Union[str, Path]
+JsonMapping = Mapping[str, Any]
+
+
+class UscodeReleaseError(ValueError):
+    """Base error for Title 35 release-point acquisition failures."""
+
+
+class MissingReleasePointError(UscodeReleaseError):
+    """Raised when release-point identity cannot be established."""
+
+
+class FixtureSchemaError(UscodeReleaseError):
+    """Raised when a fixture package is malformed."""
+
+
+class SectionNotFoundError(UscodeReleaseError):
+    """Raised when a requested section is not present in the acquisition."""
+
+
+class ResolutionStatus(str, Enum):
+    """Outcome of release-point or section resolution."""
+
+    RESOLVED = "resolved"
+    UNKNOWN = "unknown"
+    PARTIAL = "partial"
+    ERROR = "error"
+
+
+class SourceFormat(str, Enum):
+    """Supported U.S. Code source packaging formats."""
+
+    USLM = "uslm"
+    XML = "xml"
+    HTML = "html"
+    HTM = "htm"
+    PDF = "pdf"
+    ZIP = "zip"
+
+    @classmethod
+    def coerce(cls, value: Any) -> "SourceFormat":
+        if isinstance(value, SourceFormat):
+            return value
+        text = str(value or "").strip().lower()
+        aliases = {
+            "uslm": cls.USLM,
+            "uslm+xml": cls.USLM,
+            "application/uslm+xml": cls.USLM,
+            "xml": cls.XML,
+            "application/xml": cls.XML,
+            "text/xml": cls.XML,
+            "html": cls.HTML,
+            "htm": cls.HTM,
+            "text/html": cls.HTML,
+            "pdf": cls.PDF,
+            "application/pdf": cls.PDF,
+            "zip": cls.ZIP,
+            "application/zip": cls.ZIP,
+        }
+        if text not in aliases:
+            raise UscodeReleaseError(f"unsupported source format: {value!r}")
+        return aliases[text]
+
+
+class ExclusionKind(str, Enum):
+    """Kinds of release-point exclusions / classification gaps."""
+
+    UNCODIFIED_SLIP_LAW = "uncodified_slip_law"
+    CLASSIFICATION_GAP = "classification_gap"
+    POSITIVE_LAW_PENDING = "positive_law_pending"
+    EDITORIAL_NOTE = "editorial_note"
+    OMITTED = "omitted"
+    TRANSFERRED = "transferred"
+    OTHER = "other"
+
+    @classmethod
+    def coerce(cls, value: Any) -> "ExclusionKind":
+        if isinstance(value, ExclusionKind):
+            return value
+        text = str(value or "").strip().lower().replace("-", "_").replace(" ", "_")
+        for kind in cls:
+            if kind.value == text or kind.name.lower() == text:
+                return kind
+        return cls.OTHER
+
+
+def _require_non_empty_str(value: Any, name: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise UscodeReleaseError(f"{name} must be a non-empty string")
+    if "\x00" in value:
+        raise UscodeReleaseError(f"{name} must not contain NUL")
+    return value.strip()
+
+
+def _optional_str(value: Any) -> Optional[str]:
+    if value is None or value == "":
+        return None
+    return _require_non_empty_str(value, "value")
+
+
+def _require_sha256(value: Any, name: str = "sha256") -> str:
+    text = _require_non_empty_str(value, name).lower()
+    if not _SHA256_RE.fullmatch(text):
+        raise UscodeReleaseError(f"{name} must be a lowercase 64-char hex SHA-256")
+    return text
+
+
+def _parse_utc(value: Any, *, name: str = "retrieved_at") -> datetime:
+    if isinstance(value, datetime):
+        dt = value
+    elif isinstance(value, str):
+        text = value.strip()
+        if text.endswith("Z"):
+            text = text[:-1] + "+00:00"
+        try:
+            dt = datetime.fromisoformat(text)
+        except ValueError as exc:
+            raise UscodeReleaseError(f"{name} must be ISO-8601 datetime") from exc
+    else:
+        raise UscodeReleaseError(f"{name} must be a datetime or ISO-8601 string")
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    else:
+        dt = dt.astimezone(timezone.utc)
+    return dt
+
+
+def _format_utc(dt: datetime) -> str:
+    normalized = dt.astimezone(timezone.utc).replace(microsecond=(dt.microsecond // 1000) * 1000)
+    return normalized.isoformat().replace("+00:00", "Z")
+
+
+def _parse_optional_date(value: Any) -> Optional[date]:
+    if value is None or value == "":
+        return None
+    if isinstance(value, date) and not isinstance(value, datetime):
+        return value
+    if isinstance(value, datetime):
+        return value.date()
+    if isinstance(value, str):
+        return date.fromisoformat(value.strip()[:10])
+    raise UscodeReleaseError(f"invalid date value: {value!r}")
+
+
+def _date_to_str(value: Optional[date]) -> Optional[str]:
+    return None if value is None else value.isoformat()
+
+
+def _deep_sorted(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return {str(k): _deep_sorted(value[k]) for k in sorted(value.keys(), key=lambda x: str(x))}
+    if isinstance(value, (list, tuple)):
+        return [_deep_sorted(v) for v in value]
+    return value
+
+
+def normalize_title(title: Any) -> str:
+    """Normalize a U.S. Code title number to a stable string (e.g. ``\"35\"``)."""
+
+    text = str(title if title is not None else "").strip()
+    if not text:
+        raise UscodeReleaseError("title must be non-empty")
+    if text.isdigit():
+        return str(int(text))
+    # Preserve lettered titles (e.g. 10a) in lowercase.
+    return text.lower()
+
+
+def normalize_section_token(section: Any) -> str:
+    """Normalize a section citation token to a stable section number.
+
+    Accepts ``122``, ``§ 122``, ``section 122``, ``35 U.S.C. § 122``, etc.
+    Parenthetical subsections on the section number (``181(a)``) are preserved
+    when present; bare integers are returned without leading zeros.
+    """
+
+    if section is None:
+        raise UscodeReleaseError("section must be non-empty")
+    text = str(section).strip()
+    if not text:
+        raise UscodeReleaseError("section must be non-empty")
+
+    # Prefer the last § / section-like token when a full citation is supplied.
+    candidates = list(_SECTION_TOKEN_RE.finditer(text))
+    if candidates:
+        raw = candidates[-1].group("section")
+    else:
+        raw = text
+
+    raw = raw.strip().lstrip("§").strip()
+    # Collapse whitespace inside parentheticals already stripped by the regex.
+    raw = re.sub(r"\s+", "", raw)
+
+    # Numeric base without leading zeros: 0122 -> 122, keep lettered tails.
+    m = re.match(r"^0*(\d+)([A-Za-z0-9.\-()]*)$", raw)
+    if m:
+        return f"{int(m.group(1))}{m.group(2)}"
+    return raw
+
+
+def stable_section_identity(
+    *,
+    title: Any = DEFAULT_TITLE,
+    section: Any,
+    jurisdiction: str = DEFAULT_JURISDICTION,
+) -> str:
+    """Return a format-independent stable section identity.
+
+    Shape: ``usc:{jurisdiction}:{title}:{section}`` (lower-case jurisdiction).
+    Source packaging format (USLM/XML/HTML/PDF) is intentionally excluded so
+    dual-format acquisitions of the same statute share one identity.
+    """
+
+    title_n = normalize_title(title)
+    section_n = normalize_section_token(section)
+    jur = _require_non_empty_str(jurisdiction, "jurisdiction").lower()
+    return f"usc:{jur}:{title_n}:{section_n}"
+
+
+def parse_release_point_id(value: Any) -> tuple[str, str, str]:
+    """Parse a release-point token into ``(canonical_id, congress, release)``.
+
+    Accepts ``us/pl/118/45``, ``118-45``, ``118/45``. Rejects ``latest``.
+    """
+
+    text = _require_non_empty_str(value, "release_point")
+    reject_hard_coded_latest(text, field_name="release_point")
+    match = _RELEASE_POINT_RE.fullmatch(text.replace(" ", ""))
+    if not match:
+        # Also accept already-canonical paths with us/pl/ prefix only partially.
+        match = _RELEASE_POINT_RE.search(text)
+    if not match:
+        raise UscodeReleaseError(f"unrecognized release_point: {value!r}")
+    congress = str(int(match.group("congress")))
+    release = str(match.group("release")).strip()
+    if not release or release.lower() == "latest":
+        raise HardCodedLatestEditionError(
+            "release_point must not use the hard-coded token 'latest'"
+        )
+    canonical = f"us/pl/{congress}/{release}"
+    return canonical, congress, release
+
+
+def ushouse_title_code(title: Any) -> str:
+    """Return the two-digit (or lettered) House OLRC title code."""
+
+    text = normalize_title(title)
+    if text.isdigit():
+        return f"{int(text):02d}"
+    return text.lower()
+
+
+def ushouse_releasepoint_zip_url(
+    *,
+    congress: Any,
+    release: Any,
+    title: Any = DEFAULT_TITLE,
+    format_kind: SourceFormat | str = SourceFormat.HTML,
+) -> str:
+    """Build a House OLRC release-point zip URL for one title package."""
+
+    canonical, congress_s, release_s = parse_release_point_id(f"{congress}/{release}")
+    del canonical  # used only for validation
+    code = ushouse_title_code(title)
+    fmt = SourceFormat.coerce(format_kind)
+    prefix = {
+        SourceFormat.HTML: "htm",
+        SourceFormat.HTM: "htm",
+        SourceFormat.XML: "xml",
+        SourceFormat.USLM: "xml",
+        SourceFormat.PDF: "pdf",
+        SourceFormat.ZIP: "htm",
+    }[fmt]
+    return (
+        f"{USHOUSE_RELEASEPOINT_BASE}/us/pl/{congress_s}/{release_s}/"
+        f"{prefix}_usc{code}@{congress_s}-{release_s}.zip"
+    )
+
+
+def govinfo_title_package_id(*, year: Any, title: Any = DEFAULT_TITLE) -> str:
+    """Return a concrete GovInfo USCODE package id (never ``latest``)."""
+
+    year_s = _require_non_empty_str(str(year), "year")
+    reject_hard_coded_latest(year_s, field_name="year")
+    if not year_s.isdigit():
+        raise UscodeReleaseError(f"year must be numeric, got {year!r}")
+    title_n = normalize_title(title)
+    return f"USCODE-{year_s}-title{title_n}"
+
+
+def govinfo_title_zip_url(*, year: Any, title: Any = DEFAULT_TITLE) -> str:
+    package = govinfo_title_package_id(year=year, title=title)
+    return f"{GOVINFO_CONTENT_BASE}/{package}/zip/{package}.zip"
+
+
+def content_sha256(data: bytes | str) -> str:
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    return hashlib.sha256(data).hexdigest()
+
+
+@dataclass(frozen=True, slots=True)
+class ReleasePoint:
+    """Exact House OLRC or GovInfo U.S. Code release identity."""
+
+    release_point: str
+    provider: str
+    title: str = DEFAULT_TITLE
+    congress: Optional[str] = None
+    release: Optional[str] = None
+    govinfo_package_id: Optional[str] = None
+    edition: Optional[str] = None
+    year: Optional[str] = None
+    source_url: Optional[str] = None
+    content_sha256: Optional[str] = None
+    retrieved_at: Optional[datetime] = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self, "release_point", _require_non_empty_str(self.release_point, "release_point")
+        )
+        reject_hard_coded_latest(self.release_point, field_name="release_point")
+        object.__setattr__(self, "provider", _require_non_empty_str(self.provider, "provider"))
+        object.__setattr__(self, "title", normalize_title(self.title))
+        if self.congress is not None:
+            object.__setattr__(self, "congress", str(int(str(self.congress).strip())))
+        if self.release is not None:
+            rel = _require_non_empty_str(str(self.release), "release")
+            reject_hard_coded_latest(rel, field_name="release")
+            object.__setattr__(self, "release", rel)
+        if self.govinfo_package_id is not None:
+            pkg = _require_non_empty_str(self.govinfo_package_id, "govinfo_package_id")
+            reject_hard_coded_latest(pkg, field_name="govinfo_package_id")
+            object.__setattr__(self, "govinfo_package_id", pkg)
+        if self.edition is not None:
+            ed = _require_non_empty_str(self.edition, "edition")
+            reject_hard_coded_latest(ed, field_name="edition")
+            object.__setattr__(self, "edition", ed)
+        if self.year is not None:
+            object.__setattr__(self, "year", _require_non_empty_str(str(self.year), "year"))
+            reject_hard_coded_latest(self.year, field_name="year")
+        if self.source_url is not None:
+            object.__setattr__(
+                self, "source_url", _require_non_empty_str(self.source_url, "source_url")
+            )
+        if self.content_sha256 is not None:
+            object.__setattr__(
+                self, "content_sha256", _require_sha256(self.content_sha256, "content_sha256")
+            )
+        if self.retrieved_at is not None:
+            object.__setattr__(
+                self, "retrieved_at", _parse_utc(self.retrieved_at, name="retrieved_at")
+            )
+        if not isinstance(self.metadata, Mapping):
+            raise UscodeReleaseError("metadata must be a mapping")
+        object.__setattr__(self, "metadata", dict(self.metadata))
+
+    @property
+    def canonical_id(self) -> str:
+        return self.release_point
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "congress": self.congress,
+            "content_sha256": self.content_sha256,
+            "edition": self.edition,
+            "govinfo_package_id": self.govinfo_package_id,
+            "metadata": _deep_sorted(self.metadata),
+            "provider": self.provider,
+            "release": self.release,
+            "release_point": self.release_point,
+            "retrieved_at": None if self.retrieved_at is None else _format_utc(self.retrieved_at),
+            "source_url": self.source_url,
+            "title": self.title,
+            "year": self.year,
+        }
+
+    @classmethod
+    def from_dict(cls, value: JsonMapping) -> "ReleasePoint":
+        if not isinstance(value, Mapping):
+            raise UscodeReleaseError("release point must be a mapping")
+        release_point = value.get("release_point")
+        congress = value.get("congress")
+        release = value.get("release")
+        if release_point:
+            canonical, c, r = parse_release_point_id(release_point)
+            congress = congress or c
+            release = release or r
+            release_point = canonical
+        elif congress is not None and release is not None:
+            release_point, congress, release = parse_release_point_id(f"{congress}/{release}")
+        elif value.get("govinfo_package_id"):
+            # GovInfo annual package used as the release identity.
+            pkg = _require_non_empty_str(value.get("govinfo_package_id"), "govinfo_package_id")
+            reject_hard_coded_latest(pkg, field_name="govinfo_package_id")
+            release_point = pkg
+        else:
+            raise MissingReleasePointError(
+                "release_point, congress/release, or govinfo_package_id is required"
+            )
+        return cls(
+            release_point=str(release_point),
+            provider=str(value.get("provider") or "ushouse"),
+            title=value.get("title", DEFAULT_TITLE),
+            congress=None if congress is None else str(congress),
+            release=None if release is None else str(release),
+            govinfo_package_id=value.get("govinfo_package_id"),
+            edition=value.get("edition"),
+            year=value.get("year"),
+            source_url=value.get("source_url"),
+            content_sha256=value.get("content_sha256"),
+            retrieved_at=value.get("retrieved_at"),
+            metadata=value.get("metadata") or {},
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ReleaseExclusion:
+    """An uncodified, classification-gap, or related exclusion for a release."""
+
+    kind: ExclusionKind
+    citation: str
+    reason: str
+    affects_sections: tuple[str, ...] = ()
+    public_law: Optional[str] = None
+    notes: Optional[str] = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "kind", ExclusionKind.coerce(self.kind))
+        object.__setattr__(self, "citation", _require_non_empty_str(self.citation, "citation"))
+        object.__setattr__(self, "reason", _require_non_empty_str(self.reason, "reason"))
+        sections: list[str] = []
+        for item in self.affects_sections or ():
+            sections.append(normalize_section_token(item))
+        object.__setattr__(self, "affects_sections", tuple(sections))
+        if self.public_law is not None:
+            object.__setattr__(
+                self, "public_law", _require_non_empty_str(self.public_law, "public_law")
+            )
+        if self.notes is not None:
+            object.__setattr__(self, "notes", _require_non_empty_str(self.notes, "notes"))
+        if not isinstance(self.metadata, Mapping):
+            raise UscodeReleaseError("metadata must be a mapping")
+        object.__setattr__(self, "metadata", dict(self.metadata))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "affects_sections": list(self.affects_sections),
+            "citation": self.citation,
+            "kind": self.kind.value,
+            "metadata": _deep_sorted(self.metadata),
+            "notes": self.notes,
+            "public_law": self.public_law,
+            "reason": self.reason,
+        }
+
+    @classmethod
+    def from_dict(cls, value: JsonMapping) -> "ReleaseExclusion":
+        if not isinstance(value, Mapping):
+            raise UscodeReleaseError("exclusion must be a mapping")
+        affects = value.get("affects_sections") or ()
+        return cls(
+            kind=ExclusionKind.coerce(value.get("kind", ExclusionKind.OTHER)),
+            citation=str(value.get("citation") or value.get("public_law") or "unspecified"),
+            reason=str(value.get("reason") or "classification gap"),
+            affects_sections=tuple(affects),
+            public_law=value.get("public_law"),
+            notes=value.get("notes"),
+            metadata=value.get("metadata") or {},
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class FormatArtifact:
+    """One packaging format of a section or title package."""
+
+    format: SourceFormat
+    media_type: str
+    artifact_sha256: str
+    source_url: str
+    byte_size: Optional[int] = None
+    upstream_package_id: Optional[str] = None
+    role: IdentityRole = IdentityRole.OFFICIAL_ARTIFACT
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "format", SourceFormat.coerce(self.format))
+        object.__setattr__(
+            self, "media_type", _require_non_empty_str(self.media_type, "media_type")
+        )
+        object.__setattr__(
+            self, "artifact_sha256", _require_sha256(self.artifact_sha256, "artifact_sha256")
+        )
+        object.__setattr__(
+            self, "source_url", _require_non_empty_str(self.source_url, "source_url")
+        )
+        if self.byte_size is not None and (not isinstance(self.byte_size, int) or self.byte_size < 0):
+            raise UscodeReleaseError("byte_size must be a non-negative int")
+        if self.upstream_package_id is not None:
+            pkg = _require_non_empty_str(self.upstream_package_id, "upstream_package_id")
+            reject_hard_coded_latest(pkg, field_name="upstream_package_id")
+            object.__setattr__(self, "upstream_package_id", pkg)
+        if not isinstance(self.role, IdentityRole):
+            object.__setattr__(self, "role", IdentityRole(str(self.role)))
+
+    def to_artifact_identity(self, *, provider: str, source_id: str) -> ArtifactIdentity:
+        return ArtifactIdentity(
+            provider=provider,
+            source_id=source_id,
+            artifact_sha256=self.artifact_sha256,
+            source_url=self.source_url,
+            media_type=self.media_type,
+            byte_size=self.byte_size,
+            upstream_package_id=self.upstream_package_id,
+            role=self.role,
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "artifact_sha256": self.artifact_sha256,
+            "byte_size": self.byte_size,
+            "format": self.format.value,
+            "media_type": self.media_type,
+            "role": self.role.value,
+            "source_url": self.source_url,
+            "upstream_package_id": self.upstream_package_id,
+        }
+
+    @classmethod
+    def from_dict(cls, value: JsonMapping) -> "FormatArtifact":
+        if not isinstance(value, Mapping):
+            raise UscodeReleaseError("format artifact must be a mapping")
+        role_raw = value.get("role", IdentityRole.OFFICIAL_ARTIFACT.value)
+        role = role_raw if isinstance(role_raw, IdentityRole) else IdentityRole(str(role_raw))
+        return cls(
+            format=SourceFormat.coerce(value.get("format") or value.get("source_format")),
+            media_type=str(value.get("media_type") or "application/octet-stream"),
+            artifact_sha256=str(value.get("artifact_sha256") or value.get("sha256")),
+            source_url=str(value.get("source_url") or value.get("url")),
+            byte_size=value.get("byte_size"),
+            upstream_package_id=value.get("upstream_package_id"),
+            role=role,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class UscodeSectionRecord:
+    """One Title section resolved against a concrete release point."""
+
+    title: str
+    section: str
+    stable_id: str
+    heading: Optional[str] = None
+    citation: Optional[str] = None
+    text_excerpt: Optional[str] = None
+    formats: Mapping[str, FormatArtifact] = field(default_factory=dict)
+    status: ResolutionStatus = ResolutionStatus.RESOLVED
+    release_point: Optional[str] = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        title_n = normalize_title(self.title)
+        section_n = normalize_section_token(self.section)
+        object.__setattr__(self, "title", title_n)
+        object.__setattr__(self, "section", section_n)
+        stable = self.stable_id or stable_section_identity(title=title_n, section=section_n)
+        # Guard: supplied stable_id must match format-independent identity.
+        expected = stable_section_identity(title=title_n, section=section_n)
+        if stable != expected:
+            # Re-normalize rather than fail on minor presentation differences.
+            stable = expected
+        object.__setattr__(self, "stable_id", stable)
+        if self.heading is not None:
+            object.__setattr__(self, "heading", _require_non_empty_str(self.heading, "heading"))
+        if self.citation is not None:
+            object.__setattr__(
+                self, "citation", _require_non_empty_str(self.citation, "citation")
+            )
+        else:
+            object.__setattr__(self, "citation", f"{title_n} U.S.C. § {section_n}")
+        if self.text_excerpt is not None:
+            object.__setattr__(self, "text_excerpt", str(self.text_excerpt))
+        fmt_map: dict[str, FormatArtifact] = {}
+        for key, art in (self.formats or {}).items():
+            if isinstance(art, FormatArtifact):
+                fmt_map[SourceFormat.coerce(key).value] = art
+            elif isinstance(art, Mapping):
+                payload = dict(art)
+                payload.setdefault("format", key)
+                fmt_map[SourceFormat.coerce(key).value] = FormatArtifact.from_dict(payload)
+            else:
+                raise UscodeReleaseError(f"invalid format artifact for {key!r}")
+        object.__setattr__(self, "formats", fmt_map)
+        if not isinstance(self.status, ResolutionStatus):
+            object.__setattr__(self, "status", ResolutionStatus(str(self.status)))
+        if self.release_point is not None:
+            object.__setattr__(
+                self,
+                "release_point",
+                _require_non_empty_str(self.release_point, "release_point"),
+            )
+            reject_hard_coded_latest(self.release_point, field_name="release_point")
+        if not isinstance(self.metadata, Mapping):
+            raise UscodeReleaseError("metadata must be a mapping")
+        object.__setattr__(self, "metadata", dict(self.metadata))
+
+    def identity_for_all_formats(self) -> str:
+        """Stable identity shared by every packaging format of this section."""
+
+        return self.stable_id
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "citation": self.citation,
+            "formats": {k: v.to_dict() for k, v in sorted(self.formats.items())},
+            "heading": self.heading,
+            "metadata": _deep_sorted(self.metadata),
+            "release_point": self.release_point,
+            "section": self.section,
+            "stable_id": self.stable_id,
+            "status": self.status.value,
+            "text_excerpt": self.text_excerpt,
+            "title": self.title,
+        }
+
+    @classmethod
+    def from_dict(cls, value: JsonMapping) -> "UscodeSectionRecord":
+        if not isinstance(value, Mapping):
+            raise UscodeReleaseError("section record must be a mapping")
+        title = value.get("title", DEFAULT_TITLE)
+        section = value.get("section")
+        if section is None:
+            raise UscodeReleaseError("section is required")
+        status_raw = value.get("status", ResolutionStatus.RESOLVED.value)
+        status = (
+            status_raw
+            if isinstance(status_raw, ResolutionStatus)
+            else ResolutionStatus(str(status_raw))
+        )
+        return cls(
+            title=str(title),
+            section=str(section),
+            stable_id=str(
+                value.get("stable_id")
+                or stable_section_identity(title=title, section=section)
+            ),
+            heading=value.get("heading"),
+            citation=value.get("citation"),
+            text_excerpt=value.get("text_excerpt"),
+            formats=value.get("formats") or {},
+            status=status,
+            release_point=value.get("release_point"),
+            metadata=value.get("metadata") or {},
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class UscodeReleaseAcquisition:
+    """Result of acquiring one Title 35 release point and its sections."""
+
+    status: ResolutionStatus
+    release_point: Optional[ReleasePoint]
+    exclusions: tuple[ReleaseExclusion, ...]
+    sections: Mapping[str, UscodeSectionRecord]
+    authority_source: Optional[AuthoritySourceRecord] = None
+    receipt: Optional[SourceReceipt] = None
+    title: str = DEFAULT_TITLE
+    notes: Optional[str] = None
+    unknown_reason: Optional[str] = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.status, ResolutionStatus):
+            object.__setattr__(self, "status", ResolutionStatus(str(self.status)))
+        object.__setattr__(self, "title", normalize_title(self.title))
+        object.__setattr__(self, "exclusions", tuple(self.exclusions or ()))
+        sec_map: dict[str, UscodeSectionRecord] = {}
+        for key, sec in (self.sections or {}).items():
+            if isinstance(sec, UscodeSectionRecord):
+                record = sec
+            elif isinstance(sec, Mapping):
+                record = UscodeSectionRecord.from_dict(sec)
+            else:
+                raise UscodeReleaseError("sections values must be mappings or records")
+            sec_map[record.section] = record
+        object.__setattr__(self, "sections", sec_map)
+        if not isinstance(self.metadata, Mapping):
+            raise UscodeReleaseError("metadata must be a mapping")
+        object.__setattr__(self, "metadata", dict(self.metadata))
+
+    @property
+    def is_unknown(self) -> bool:
+        return self.status is ResolutionStatus.UNKNOWN
+
+    def get_section(self, section: Any) -> UscodeSectionRecord:
+        token = normalize_section_token(section)
+        try:
+            return self.sections[token]
+        except KeyError as exc:
+            raise SectionNotFoundError(
+                f"section {token!r} not present in acquisition "
+                f"(release={None if self.release_point is None else self.release_point.release_point})"
+            ) from exc
+
+    def resolve_section(self, section: Any) -> UscodeSectionRecord:
+        """Resolve a section or return an unknown-status record when release is missing."""
+
+        if self.status is ResolutionStatus.UNKNOWN or self.release_point is None:
+            token = normalize_section_token(section)
+            return UscodeSectionRecord(
+                title=self.title,
+                section=token,
+                stable_id=stable_section_identity(title=self.title, section=token),
+                status=ResolutionStatus.UNKNOWN,
+                release_point=None,
+                metadata={"unknown_reason": self.unknown_reason or "missing release point"},
+            )
+        return self.get_section(section)
+
+    def recorded_exclusions(self) -> tuple[ReleaseExclusion, ...]:
+        return self.exclusions
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "authority_source": (
+                None if self.authority_source is None else self.authority_source.to_dict()
+            ),
+            "exclusions": [e.to_dict() for e in self.exclusions],
+            "metadata": _deep_sorted(self.metadata),
+            "notes": self.notes,
+            "receipt": None if self.receipt is None else self.receipt.to_dict(),
+            "release_point": None if self.release_point is None else self.release_point.to_dict(),
+            "schema_version": SCHEMA_VERSION,
+            "sections": {
+                k: v.to_dict() for k, v in sorted(self.sections.items(), key=lambda kv: kv[0])
+            },
+            "status": self.status.value,
+            "title": self.title,
+            "unknown_reason": self.unknown_reason,
+        }
+
+    def to_canonical_json(self) -> str:
+        return canonical_json_dumps(self.to_dict())
+
+
+def default_fixture_dir() -> Path:
+    """Return the repository Title 35 fixture directory when present."""
+
+    # processors/legal_scrapers/federal_scrapers/thisfile -> repo root is 5 parents up
+    here = Path(__file__).resolve()
+    candidates = [
+        here.parents[4] / "tests" / "fixtures" / "legal_data" / "patent_authorities" / "uscode",
+        Path.cwd() / "tests" / "fixtures" / "legal_data" / "patent_authorities" / "uscode",
+    ]
+    for path in candidates:
+        if path.is_dir():
+            return path
+    return candidates[0]
+
+
+def load_json_fixture(path: PathLike) -> dict[str, Any]:
+    p = Path(path)
+    with p.open("r", encoding="utf-8") as handle:
+        payload = json.load(handle)
+    if not isinstance(payload, Mapping):
+        raise FixtureSchemaError(f"fixture root must be a mapping: {p}")
+    return dict(payload)
+
+
+def _media_type_for_format(fmt: SourceFormat) -> str:
+    return {
+        SourceFormat.USLM: "application/uslm+xml",
+        SourceFormat.XML: "application/xml",
+        SourceFormat.HTML: "text/html",
+        SourceFormat.HTM: "text/html",
+        SourceFormat.PDF: "application/pdf",
+        SourceFormat.ZIP: "application/zip",
+    }[fmt]
+
+
+def _build_format_map(
+    raw_formats: Mapping[str, Any] | None,
+    *,
+    release: ReleasePoint,
+    section: str,
+) -> dict[str, FormatArtifact]:
+    out: dict[str, FormatArtifact] = {}
+    if not raw_formats:
+        return out
+    for key, item in raw_formats.items():
+        fmt = SourceFormat.coerce(key)
+        if isinstance(item, FormatArtifact):
+            out[fmt.value] = item
+            continue
+        if not isinstance(item, Mapping):
+            raise FixtureSchemaError(f"formats[{key!r}] must be a mapping")
+        payload = dict(item)
+        payload.setdefault("format", fmt.value)
+        payload.setdefault("media_type", _media_type_for_format(fmt))
+        if "artifact_sha256" not in payload and "sha256" not in payload:
+            # Deterministic synthetic digest for compact recipes that omit bytes.
+            seed = f"{release.release_point}|{release.title}|{section}|{fmt.value}"
+            payload["artifact_sha256"] = content_sha256(seed)
+        if "source_url" not in payload and "url" not in payload:
+            if release.congress and release.release:
+                payload["source_url"] = ushouse_releasepoint_zip_url(
+                    congress=release.congress,
+                    release=release.release,
+                    title=release.title,
+                    format_kind=fmt,
+                )
+            elif release.source_url:
+                payload["source_url"] = release.source_url
+            else:
+                payload["source_url"] = (
+                    f"{USHOUSE_DOWNLOAD_PAGE}#title-{release.title}-section-{section}-{fmt.value}"
+                )
+        if "upstream_package_id" not in payload:
+            payload["upstream_package_id"] = release.govinfo_package_id or release.release_point
+        out[fmt.value] = FormatArtifact.from_dict(payload)
+    return out
+
+
+def _build_authority_source(
+    release: ReleasePoint,
+    *,
+    formats: Mapping[str, FormatArtifact] | None = None,
+    receipt: SourceReceipt | None = None,
+    verification_state: VerificationState = VerificationState.UNVERIFIED,
+) -> AuthoritySourceRecord:
+    official: Optional[ArtifactIdentity] = None
+    derived: Optional[ArtifactIdentity] = None
+    fmt_map = dict(formats or {})
+
+    preferred_official = (
+        SourceFormat.USLM.value,
+        SourceFormat.XML.value,
+        SourceFormat.PDF.value,
+        SourceFormat.HTML.value,
+        SourceFormat.HTM.value,
+        SourceFormat.ZIP.value,
+    )
+    for key in preferred_official:
+        if key in fmt_map:
+            art = fmt_map[key]
+            official = art.to_artifact_identity(
+                provider=release.provider,
+                source_id=f"uscode-{release.title}:{release.release_point}:{key}",
+            )
+            break
+
+    if official is None and release.content_sha256 and release.source_url:
+        official = ArtifactIdentity(
+            provider=release.provider,
+            source_id=f"uscode-{release.title}:{release.release_point}",
+            artifact_sha256=release.content_sha256,
+            source_url=release.source_url,
+            role=IdentityRole.OFFICIAL_ARTIFACT,
+            upstream_package_id=release.govinfo_package_id or release.release_point,
+        )
+
+    # Prefer HTML as derived presentation when a richer official format exists.
+    if official is not None:
+        for key in (SourceFormat.HTML.value, SourceFormat.HTM.value):
+            if key in fmt_map and fmt_map[key].artifact_sha256 != official.artifact_sha256:
+                derived = fmt_map[key].to_artifact_identity(
+                    provider=release.provider,
+                    source_id=f"uscode-{release.title}:{release.release_point}:{key}:presentation",
+                )
+                derived = ArtifactIdentity(
+                    provider=derived.provider,
+                    source_id=derived.source_id,
+                    artifact_sha256=derived.artifact_sha256,
+                    source_url=derived.source_url,
+                    media_type=derived.media_type,
+                    byte_size=derived.byte_size,
+                    upstream_package_id=derived.upstream_package_id,
+                    role=IdentityRole.DERIVED_PRESENTATION,
+                )
+                break
+
+    edition = release.edition or release.release_point
+    return AuthoritySourceRecord(
+        source_key=f"uscode-{release.title}-{release.release_point.replace('/', '-')}",
+        authority_tier=AuthorityTier.OFFICIAL_BASE,
+        collection=COLLECTION_USCODE,
+        jurisdiction=DEFAULT_JURISDICTION,
+        title=release.title,
+        citation=f"{release.title} U.S.C.",
+        edition=edition,
+        version=release.release_point,
+        release_point=release.release_point,
+        official_artifact=official,
+        derived_presentation=derived,
+        receipt=receipt,
+        verification_state=verification_state,
+        notes="House OLRC / GovInfo U.S. Code release-point acquisition",
+        metadata={
+            "congress": release.congress,
+            "release": release.release,
+            "govinfo_package_id": release.govinfo_package_id,
+            "year": release.year,
+            "processor_schema": SCHEMA_VERSION,
+            "authority_schema": AUTHORITY_SCHEMA_VERSION,
+        },
+    )
+
+
+def _build_receipt(release: ReleasePoint) -> Optional[SourceReceipt]:
+    if not release.source_url and not release.content_sha256:
+        return None
+    endpoint = release.source_url or USHOUSE_DOWNLOAD_PAGE
+    retrieved = release.retrieved_at or datetime(1970, 1, 1, tzinfo=timezone.utc)
+    return SourceReceipt(
+        endpoint=endpoint,
+        retrieved_at=retrieved,
+        response_status=200,
+        sanitized_request={"method": "GET", "path": endpoint},
+        upstream_id=release.govinfo_package_id or release.release_point,
+        content_sha256=release.content_sha256,
+        retry_count=0,
+        cache_hit=False,
+        media_type="application/zip",
+        metadata={"provider": release.provider, "title": release.title},
+    )
+
+
+class UscodeReleaseProcessor:
+    """Acquire Title 35 U.S. Code content at an exact release point.
+
+    Primary path is fixture replay (recorded OLRC/GovInfo metadata). Live
+    network discovery is deliberately not performed by default so tests and
+    offline operators remain deterministic.
+    """
+
+    def __init__(
+        self,
+        *,
+        fixture_dir: PathLike | None = None,
+        registry: AuthoritySourceRegistry | None = None,
+        retry_cache_policy: RetryCachePolicy | None = None,
+        default_title: str = DEFAULT_TITLE,
+    ) -> None:
+        self.fixture_dir = Path(fixture_dir) if fixture_dir else default_fixture_dir()
+        self.registry = registry if registry is not None else AuthoritySourceRegistry(
+            default_retry_cache_policy=retry_cache_policy
+        )
+        self.default_title = normalize_title(default_title)
+        self._acquisitions: dict[str, UscodeReleaseAcquisition] = {}
+
+    # ------------------------------------------------------------------
+    # Identity helpers (format-independent)
+    # ------------------------------------------------------------------
+
+    def stable_section_identity(self, section: Any, *, title: Any | None = None) -> str:
+        return stable_section_identity(
+            title=self.default_title if title is None else title,
+            section=section,
+        )
+
+    def identities_equal_across_formats(
+        self,
+        *,
+        title: Any,
+        section: Any,
+        formats: Sequence[SourceFormat | str],
+    ) -> bool:
+        """Return True when every *format* maps to the same stable identity."""
+
+        base = stable_section_identity(title=title, section=section)
+        for _fmt in formats:
+            # Format is intentionally ignored for identity.
+            if stable_section_identity(title=title, section=section) != base:
+                return False
+        return len(list(formats)) > 0
+
+    # ------------------------------------------------------------------
+    # Fixture acquisition
+    # ------------------------------------------------------------------
+
+    def load_fixture_package(self, path: PathLike | None = None) -> dict[str, Any]:
+        """Load a compact Title 35 release fixture (recipe or full package)."""
+
+        target = Path(path) if path is not None else self._default_package_path()
+        if target.is_dir():
+            recipe = target / "title35_release_recipe.json"
+            if recipe.is_file():
+                target = recipe
+            else:
+                # Merge directory components when present.
+                return self._load_fixture_directory(target)
+        payload = load_json_fixture(target)
+        schema = payload.get("schema_version")
+        if schema and schema not in {FIXTURE_SCHEMA_VERSION, SCHEMA_VERSION}:
+            # Accept forward-compatible minor variants that share the prefix.
+            if not str(schema).startswith("uscode-release"):
+                raise FixtureSchemaError(
+                    f"unsupported fixture schema_version {schema!r} in {target}"
+                )
+        return payload
+
+    def _default_package_path(self) -> Path:
+        recipe = self.fixture_dir / "title35_release_recipe.json"
+        if recipe.is_file():
+            return recipe
+        return self.fixture_dir
+
+    def _load_fixture_directory(self, directory: Path) -> dict[str, Any]:
+        release_path = directory / "release_point.json"
+        if not release_path.is_file():
+            raise FixtureSchemaError(
+                f"fixture directory {directory} lacks title35_release_recipe.json "
+                "or release_point.json"
+            )
+        payload: dict[str, Any] = {
+            "schema_version": FIXTURE_SCHEMA_VERSION,
+            "release": load_json_fixture(release_path),
+        }
+        exclusions_path = directory / "exclusions.json"
+        if exclusions_path.is_file():
+            raw = load_json_fixture(exclusions_path)
+            payload["exclusions"] = raw.get("exclusions", raw if isinstance(raw, list) else [])
+        sections_dir = directory / "sections"
+        sections: list[Any] = []
+        if sections_dir.is_dir():
+            for path in sorted(sections_dir.glob("*.json")):
+                sections.append(load_json_fixture(path))
+        payload["sections"] = sections
+        return payload
+
+    def acquire_from_fixture(
+        self,
+        path: PathLike | None = None,
+        *,
+        register: bool = True,
+    ) -> UscodeReleaseAcquisition:
+        """Acquire Title 35 content from a recorded fixture package.
+
+        Missing release identity yields :attr:`ResolutionStatus.UNKNOWN`.
+        """
+
+        payload = self.load_fixture_package(path)
+        return self.acquire_from_payload(payload, register=register)
+
+    def acquire_from_payload(
+        self,
+        payload: JsonMapping,
+        *,
+        register: bool = True,
+    ) -> UscodeReleaseAcquisition:
+        if not isinstance(payload, Mapping):
+            raise FixtureSchemaError("payload must be a mapping")
+
+        release_raw = payload.get("release") or payload.get("release_point")
+        title = normalize_title(payload.get("title") or self.default_title)
+
+        # Fail-closed: missing release data → unknown.
+        if not release_raw:
+            return UscodeReleaseAcquisition(
+                status=ResolutionStatus.UNKNOWN,
+                release_point=None,
+                exclusions=(),
+                sections={},
+                title=title,
+                unknown_reason="missing release data",
+                notes="Exact release point unavailable; section authority is unknown.",
+                metadata={"schema_version": payload.get("schema_version")},
+            )
+
+        if isinstance(release_raw, str):
+            release_raw = {"release_point": release_raw, "provider": "ushouse", "title": title}
+
+        if not isinstance(release_raw, Mapping):
+            raise FixtureSchemaError("release must be a mapping or release_point string")
+
+        # Explicit null/empty release_point field also yields unknown.
+        rp_token = release_raw.get("release_point")
+        has_congress_release = (
+            release_raw.get("congress") is not None and release_raw.get("release") is not None
+        )
+        has_govinfo = bool(release_raw.get("govinfo_package_id"))
+        if rp_token in (None, "") and not has_congress_release and not has_govinfo:
+            return UscodeReleaseAcquisition(
+                status=ResolutionStatus.UNKNOWN,
+                release_point=None,
+                exclusions=tuple(
+                    ReleaseExclusion.from_dict(e)
+                    for e in (payload.get("exclusions") or [])
+                    if isinstance(e, Mapping)
+                ),
+                sections={},
+                title=title,
+                unknown_reason="missing release data",
+                notes="Release mapping present but no concrete release identity.",
+                metadata={"schema_version": payload.get("schema_version")},
+            )
+
+        try:
+            release = ReleasePoint.from_dict({**dict(release_raw), "title": release_raw.get("title", title)})
+        except (MissingReleasePointError, HardCodedLatestEditionError, UscodeReleaseError) as exc:
+            return UscodeReleaseAcquisition(
+                status=ResolutionStatus.UNKNOWN,
+                release_point=None,
+                exclusions=(),
+                sections={},
+                title=title,
+                unknown_reason=str(exc),
+                notes="Failed to parse release point; treating authority as unknown.",
+                metadata={"schema_version": payload.get("schema_version"), "error": str(exc)},
+            )
+
+        exclusions = tuple(
+            ReleaseExclusion.from_dict(item)
+            for item in (payload.get("exclusions") or [])
+            if isinstance(item, Mapping)
+        )
+
+        package_formats = _build_format_map(
+            payload.get("package_formats") or release_raw.get("formats"),
+            release=release,
+            section="*",
+        )
+
+        sections: dict[str, UscodeSectionRecord] = {}
+        for raw_sec in payload.get("sections") or []:
+            if not isinstance(raw_sec, Mapping):
+                continue
+            sec_title = normalize_title(raw_sec.get("title", release.title))
+            sec_num = normalize_section_token(raw_sec["section"])
+            formats = _build_format_map(
+                raw_sec.get("formats"),
+                release=release,
+                section=sec_num,
+            )
+            record = UscodeSectionRecord(
+                title=sec_title,
+                section=sec_num,
+                stable_id=stable_section_identity(title=sec_title, section=sec_num),
+                heading=raw_sec.get("heading"),
+                citation=raw_sec.get("citation"),
+                text_excerpt=raw_sec.get("text_excerpt"),
+                formats=formats,
+                status=ResolutionStatus.RESOLVED,
+                release_point=release.release_point,
+                metadata=raw_sec.get("metadata") or {},
+            )
+            sections[record.section] = record
+
+        receipt = _build_receipt(release)
+        if receipt is None and release.source_url:
+            receipt = SourceReceipt(
+                endpoint=release.source_url,
+                retrieved_at=release.retrieved_at or datetime.now(timezone.utc),
+                response_status=200,
+                sanitized_request={"method": "GET"},
+                upstream_id=release.release_point,
+                content_sha256=release.content_sha256,
+            )
+
+        authority = _build_authority_source(
+            release,
+            formats=package_formats,
+            receipt=receipt,
+            verification_state=VerificationState.UNVERIFIED,
+        )
+
+        if register:
+            self.registry.register(authority, overwrite=True)
+            if receipt is not None and authority.receipt is None:
+                self.registry.attach_receipt(authority.source_key, receipt)
+
+        acquisition = UscodeReleaseAcquisition(
+            status=ResolutionStatus.RESOLVED,
+            release_point=release,
+            exclusions=exclusions,
+            sections=sections,
+            authority_source=authority,
+            receipt=receipt,
+            title=release.title,
+            notes=payload.get("notes"),
+            metadata={
+                "schema_version": payload.get("schema_version") or FIXTURE_SCHEMA_VERSION,
+                "fixture_id": payload.get("fixture_id"),
+                "exclusion_count": len(exclusions),
+                "section_count": len(sections),
+            },
+        )
+        self._acquisitions[release.release_point] = acquisition
+        return acquisition
+
+    # ------------------------------------------------------------------
+    # Resolution API
+    # ------------------------------------------------------------------
+
+    def acquire_unknown(self, *, reason: str = "missing release data", title: Any | None = None) -> UscodeReleaseAcquisition:
+        """Explicit unknown acquisition when no release can be established."""
+
+        return UscodeReleaseAcquisition(
+            status=ResolutionStatus.UNKNOWN,
+            release_point=None,
+            exclusions=(),
+            sections={},
+            title=self.default_title if title is None else normalize_title(title),
+            unknown_reason=reason,
+            notes="Exact release point unavailable; section authority is unknown.",
+        )
+
+    def resolve_patent_sensitive_sections(
+        self,
+        acquisition: UscodeReleaseAcquisition | None = None,
+        *,
+        path: PathLike | None = None,
+    ) -> dict[str, UscodeSectionRecord]:
+        """Resolve 35 USC 122 and 181–188 against a release acquisition."""
+
+        acq = acquisition if acquisition is not None else self.acquire_from_fixture(path)
+        resolved: dict[str, UscodeSectionRecord] = {}
+        for section in PATENT_SENSITIVE_SECTIONS:
+            resolved[section] = acq.resolve_section(section)
+        return resolved
+
+    def get_acquisition(self, release_point: str) -> UscodeReleaseAcquisition:
+        key, _, _ = parse_release_point_id(release_point)
+        try:
+            return self._acquisitions[key]
+        except KeyError as exc:
+            # Also allow raw key lookup (govinfo package ids).
+            if release_point in self._acquisitions:
+                return self._acquisitions[release_point]
+            raise UscodeReleaseError(f"no acquisition for release_point {release_point!r}") from exc
+
+    def list_exclusions(
+        self, acquisition: UscodeReleaseAcquisition | None = None
+    ) -> tuple[ReleaseExclusion, ...]:
+        if acquisition is None:
+            if not self._acquisitions:
+                return ()
+            # Most recent insertion order is fine; values() is insertion-ordered.
+            acquisition = next(reversed(list(self._acquisitions.values())))
+        return acquisition.recorded_exclusions()
+
+
+def build_title35_fixture_recipe(
+    *,
+    congress: int = 118,
+    release: str = "45",
+    fixture_id: str = "title35-uspl-118-45",
+) -> dict[str, Any]:
+    """Build a compact deterministic Title 35 fixture recipe for tests/tools.
+
+    Prefer this generator over bulk golden dumps that re-emit full envelopes.
+    """
+
+    canonical, congress_s, release_s = parse_release_point_id(f"{congress}/{release}")
+    content_seed = f"ushouse|{canonical}|title-35|package"
+    package_sha = content_sha256(content_seed)
+    source_url = ushouse_releasepoint_zip_url(
+        congress=congress_s, release=release_s, title="35", format_kind=SourceFormat.USLM
+    )
+
+    headings = {
+        "122": "Confidential status of applications; publication of patent applications",
+        "181": "Secrecy of certain inventions and withholding of patent",
+        "182": "Abandonment of invention for unauthorized disclosure",
+        "183": "Right to compensation",
+        "184": "Filing of application in foreign country",
+        "185": "Patent barred for filing without license",
+        "186": "Penalty",
+        "187": "Nonapplicability to certain persons",
+        "188": "Rules and regulations, delegation of power",
+    }
+    excerpts = {
+        "122": (
+            "(a) Except as provided in subsection (b), applications for patents "
+            "shall be kept in confidence by the Patent and Trademark Office..."
+        ),
+        "181": (
+            "Whenever publication or disclosure by the publication of an "
+            "application or by the grant of a patent..."
+        ),
+    }
+
+    sections: list[dict[str, Any]] = []
+    for sec in PATENT_SENSITIVE_SECTIONS:
+        formats = {}
+        for fmt in (SourceFormat.USLM, SourceFormat.HTML, SourceFormat.PDF):
+            seed = f"{canonical}|35|{sec}|{fmt.value}"
+            formats[fmt.value] = {
+                "format": fmt.value,
+                "media_type": _media_type_for_format(fmt),
+                "artifact_sha256": content_sha256(seed),
+                "source_url": ushouse_releasepoint_zip_url(
+                    congress=congress_s,
+                    release=release_s,
+                    title="35",
+                    format_kind=fmt,
+                ),
+                "byte_size": 1000 + int(sec) + (10 if fmt is SourceFormat.PDF else 0),
+                "upstream_package_id": canonical,
+            }
+        sections.append(
+            {
+                "title": "35",
+                "section": sec,
+                "heading": headings.get(sec, f"35 U.S.C. § {sec}"),
+                "citation": f"35 U.S.C. § {sec}",
+                "text_excerpt": excerpts.get(sec, f"[excerpt 35 U.S.C. § {sec}]"),
+                "formats": formats,
+            }
+        )
+
+    return {
+        "schema_version": FIXTURE_SCHEMA_VERSION,
+        "fixture_id": fixture_id,
+        "title": "35",
+        "notes": (
+            "Compact Title 35 release-point recipe. Exact release point and "
+            "uncodified/classification exclusions are recorded; sections 122 "
+            "and 181–188 resolve with format-independent stable identities."
+        ),
+        "release": {
+            "provider": "ushouse",
+            "congress": int(congress_s),
+            "release": release_s,
+            "release_point": canonical,
+            "title": "35",
+            "edition": f"olrc-{canonical.replace('/', '-')}",
+            "source_url": source_url,
+            "content_sha256": package_sha,
+            "retrieved_at": "2024-09-15T14:00:00Z",
+            "formats": {
+                "uslm": {
+                    "format": "uslm",
+                    "media_type": "application/uslm+xml",
+                    "artifact_sha256": package_sha,
+                    "source_url": source_url,
+                    "upstream_package_id": canonical,
+                },
+                "html": {
+                    "format": "html",
+                    "media_type": "text/html",
+                    "artifact_sha256": content_sha256(content_seed + "|html"),
+                    "source_url": ushouse_releasepoint_zip_url(
+                        congress=congress_s,
+                        release=release_s,
+                        title="35",
+                        format_kind=SourceFormat.HTML,
+                    ),
+                    "upstream_package_id": canonical,
+                },
+            },
+        },
+        "exclusions": [
+            {
+                "kind": "uncodified_slip_law",
+                "citation": "Pub. L. 118-100 § 3",
+                "public_law": "Pub. L. 118-100",
+                "reason": (
+                    "Enacted patent-fee adjustment not yet classified into "
+                    "positive-law Title 35 at this release point."
+                ),
+                "affects_sections": [],
+            },
+            {
+                "kind": "classification_gap",
+                "citation": "Pub. L. 117-328 div. W",
+                "public_law": "Pub. L. 117-328",
+                "reason": (
+                    "Classification table records a pending editorial "
+                    "reclassification affecting cross-references in Title 35."
+                ),
+                "affects_sections": ["122"],
+            },
+            {
+                "kind": "positive_law_pending",
+                "citation": "Uncodified national-security notice schedule",
+                "reason": (
+                    "Agency secrecy-order implementing schedule published as "
+                    "uncodified material; not part of 35 U.S.C. 181–188 text."
+                ),
+                "affects_sections": ["181", "182", "183", "184", "185", "186", "187", "188"],
+            },
+        ],
+        "sections": sections,
+    }
+
+
+def write_default_fixtures(directory: PathLike | None = None) -> Path:
+    """Materialize the default Title 35 fixture recipe and missing-release case."""
+
+    root = Path(directory) if directory is not None else default_fixture_dir()
+    root.mkdir(parents=True, exist_ok=True)
+
+    recipe = build_title35_fixture_recipe()
+    recipe_path = root / "title35_release_recipe.json"
+    recipe_path.write_text(
+        json.dumps(recipe, indent=2, sort_keys=True, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+    missing = {
+        "schema_version": FIXTURE_SCHEMA_VERSION,
+        "fixture_id": "title35-missing-release",
+        "title": "35",
+        "notes": "Release identity deliberately omitted for unknown-status tests.",
+        "release": {
+            "provider": "ushouse",
+            "title": "35",
+            "release_point": None,
+        },
+        "exclusions": [],
+        "sections": [],
+    }
+    missing_path = root / "title35_missing_release.json"
+    missing_path.write_text(
+        json.dumps(missing, indent=2, sort_keys=True, ensure_ascii=False) + "\n",
+        encoding="utf-8",
+    )
+
+    # Lightweight README for operators (not required by admission, but helpful).
+    readme = root / "README.md"
+    if not readme.exists():
+        readme.write_text(
+            "# Title 35 U.S. Code release-point fixtures\n\n"
+            "Compact recipes for PATLAW-013. Prefer `title35_release_recipe.json` "
+            "over bulk golden dumps. Missing release data is modeled in "
+            "`title35_missing_release.json` and must resolve as `unknown`.\n",
+            encoding="utf-8",
+        )
+    return root
+
+
+__all__ = [
+    "COLLECTION_USCODE",
+    "CONFIDENTIALITY_SECTION",
+    "DEFAULT_TITLE",
+    "FIXTURE_SCHEMA_VERSION",
+    "PATENT_SENSITIVE_SECTIONS",
+    "SCHEMA_VERSION",
+    "SECRECY_ORDER_SECTIONS",
+    "ExclusionKind",
+    "FixtureSchemaError",
+    "FormatArtifact",
+    "MissingReleasePointError",
+    "ReleaseExclusion",
+    "ReleasePoint",
+    "ResolutionStatus",
+    "SectionNotFoundError",
+    "SourceFormat",
+    "UscodeReleaseAcquisition",
+    "UscodeReleaseError",
+    "UscodeReleaseProcessor",
+    "UscodeSectionRecord",
+    "build_title35_fixture_recipe",
+    "content_sha256",
+    "default_fixture_dir",
+    "govinfo_title_package_id",
+    "govinfo_title_zip_url",
+    "load_json_fixture",
+    "normalize_section_token",
+    "normalize_title",
+    "parse_release_point_id",
+    "stable_section_identity",
+    "ushouse_releasepoint_zip_url",
+    "ushouse_title_code",
+    "write_default_fixtures",
+]

scrapers_and_normalizers/scripts/scrapers/legal/us_code_scraper.py

@@ -0,0 +1,7 @@
+"""Compatibility shim for legacy imports.
+
+The legal scraper implementations live under
+`ipfs_datasets_py.legal_scrapers`.
+"""
+
+from ipfs_datasets_py.processors.legal_scrapers.us_code_scraper import *  # noqa: F401,F403