Add files using upload-large-folder tool

README.md

@@ -72,14 +72,14 @@ Target Hub id (packaging metadata only): `justicedao/ipfs_peru_laws_ir`.
 
 | Field | Value |
 | --- | --- |
-| Laws (corpus units) | 0 |
+| Laws (corpus units) | 1735 |
 | Articles (corpus units) | 14345 |
-| Canonical docs | 14345 |
-| BM25 terms | 63616 |
-| BM25 postings | 1546715 |
-| Graph nodes | 20617 |
-| Graph edges | 114760 |
-| Vectors | 14345 × 384-d `thenlper/gte-small` (partial) |
+| Canonical docs | 16080 |
+| BM25 terms | 67529 |
+| BM25 postings | 2428340 |
+| Graph nodes | 23024 |
+| Graph edges | 128640 |
+| Vectors | 16080 × 384-d `thenlper/gte-small` (embedded) |
 
 ## Canonical fields
 

build.py

@@ -60,8 +60,17 @@ def _log(msg: str) -> None:
 def record_progress(event: dict[str, Any]) -> None:
     event = dict(event)
     event.setdefault("ts", datetime.now(timezone.utc).isoformat())
-    with PROGRESS.open("a", encoding="utf-8") as f:
-        f.write(json.dumps(event, ensure_ascii=False) + "\n")
+    PROGRESS.parent.mkdir(parents=True, exist_ok=True)
+    lock_path = PROGRESS.with_suffix(".lock")
+    with lock_path.open("a", encoding="utf-8") as lock_fh:
+        try:
+            import fcntl
+
+            fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX)
+        except Exception:
+            pass
+        with PROGRESS.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(event, ensure_ascii=False) + "\n")
 
 
 def _prior_dir_for(
@@ -202,7 +211,11 @@ def build_country(
         )
     )
     plan = plan_rebuild(
-        mode=mode, source_meta=source_meta, prior=prior, force=force
+        mode=mode,
+        source_meta=source_meta,
+        prior=prior,
+        force=force,
+        rebuild_stub_vectors=not skip_vectors,
     )
     if plan.skip_build:
         _log(f"skip unchanged {country['slug']} rev={plan.source_revision}")
@@ -234,6 +247,13 @@ def build_country(
     )
     if corpus.empty:
         raise RuntimeError("Normalized corpus is empty; refusing to package")
+    verdict = (norm_report or {}).get("verification") or {}
+    if verdict.get("blocks_graphrag") and not force:
+        from .verify import NormalizationAdmissionError
+
+        raise NormalizationAdmissionError(
+            f"{country['slug']} failed normalization verifiers: {verdict.get('failed_ids')}"
+        )
 
     import gc
 
@@ -243,6 +263,7 @@ def build_country(
         prior=prior,
         current_corpus=corpus,
         force=force,
+        rebuild_stub_vectors=not skip_vectors,
     )
     _log(
         f"rebuild kind={plan.kind.value} reuse_embeddings={plan.reuse_embeddings} "
@@ -394,17 +415,29 @@ def reindex_from_gaps(
     skip_vectors: bool = False,
     workers: int = 4,
     mode: str = "auto",
+    force: bool = False,
+    all_indexable: bool = False,
+    device: str = "cuda",
 ) -> list[dict[str, Any]]:
-    """Scan Hub gaps and incrementally rebuild stale/missing country IR.
+    """Rebuild country IR. Default is Hub gaps; ``all_indexable`` processes every catalog country.
 
     Default cap skips huge corpora (Finland, Dominican Republic). Pass
     ``max_corpus_rows=None`` to include them.
     """
+    from .catalog import indexable_countries
     from .coverage import gap_report
 
     if slugs is None:
-        report = gap_report(workers=workers)
-        rows = [c for c in report["countries"] if c.get("rebuild")]
+        if all_indexable:
+            rows = [{"slug": c["slug"], "corpus_rows": 0} for c in indexable_countries()]
+            _log(f"reindex all indexable n={len(rows)}")
+        else:
+            report = gap_report(workers=workers)
+            rows = [c for c in report["countries"] if c.get("rebuild")]
+            _log(
+                f"reindex targets n={len(rows)} "
+                f"(from scan rebuild={len(report.get('rebuild') or [])})"
+            )
         rows.sort(key=lambda r: int(r.get("corpus_rows") or 0))
         if max_corpus_rows is not None:
             rows = [
@@ -415,33 +448,54 @@ def reindex_from_gaps(
         if limit is not None:
             rows = rows[: int(limit)]
         slugs = [str(r["slug"]) for r in rows]
-        _log(
-            f"reindex targets n={len(slugs)} "
-            f"(from scan rebuild={len(report.get('rebuild') or [])})"
+    kwargs = {
+        "upload": upload,
+        "mode": mode,
+        "force": force,
+        "skip_vectors": skip_vectors,
+        "fetch_hub_prior_ir": True,
+        "device": device,
+    }
+    n_workers = max(1, int(workers or 1))
+    _log(f"reindex parallel workers={n_workers} countries={len(slugs)} device=cuda")
+    import multiprocessing as mp
+    from concurrent.futures import ProcessPoolExecutor, as_completed
+
+    try:
+        mp.set_start_method("spawn", force=False)
+    except RuntimeError:
+        pass
+
+    results = [None] * len(slugs)
+    with ProcessPoolExecutor(max_workers=n_workers, max_tasks_per_child=1) as pool:
+        futs = {
+            pool.submit(_reindex_one_country, (slug, kwargs)): i
+            for i, slug in enumerate(slugs)
+        }
+        for fut in as_completed(futs):
+            idx = futs[fut]
+            slug = slugs[idx]
+            try:
+                results[idx] = fut.result()
+            except Exception as exc:
+                _log(f"FAILED {slug}: {exc}")
+                results[idx] = {"country": slug, "skipped": False, "error": str(exc)}
+    return [r for r in results if r is not None]
+
+
+def _reindex_one_country(item: tuple[str, dict[str, Any]]) -> dict[str, Any]:
+    slug, kwargs = item
+    _log(f"reindex start {slug}")
+    try:
+        return build_country(slug, **kwargs)
+    except Exception as exc:
+        _log(f"FAILED {slug}: {exc}")
+        record_progress(
+            {
+                "event": "failed",
+                "country": slug,
+                "error": str(exc),
+                "traceback": traceback.format_exc(),
+            }
         )
-    results: list[dict[str, Any]] = []
-    for slug in slugs:
-        _log(f"reindex start {slug}")
-        try:
-            results.append(
-                build_country(
-                    slug,
-                    upload=upload,
-                    mode=mode,
-                    skip_vectors=skip_vectors,
-                    fetch_hub_prior_ir=True,
-                )
-            )
-        except Exception as exc:
-            _log(f"FAILED {slug}: {exc}")
-            record_progress(
-                {
-                    "event": "failed",
-                    "country": slug,
-                    "error": str(exc),
-                    "traceback": traceback.format_exc(),
-                }
-            )
-            results.append({"country": slug, "skipped": False, "error": str(exc)})
-            continue
-    return results
+        return {"country": slug, "skipped": False, "error": str(exc)}

country_laws_ir/__main__.py

@@ -66,8 +66,22 @@ def main(argv: list[str] | None = None) -> int:
     p_re.add_argument("--max-corpus-rows", type=int, default=20000,
                       help="Skip IR larger than this many rows (0 = no cap)")
     p_re.add_argument("--skip-vectors", action="store_true")
-    p_re.add_argument("--workers", type=int, default=4)
+    p_re.add_argument("--workers", type=int, default=2,
+                      help="Parallel country workers (default 2 to stay under MemAbort; CUDA encodes are file-locked)")
+    p_re.add_argument("--device", default="cuda")
     p_re.add_argument("--mode", default="auto", choices=["auto", "full", "delta"])
+    p_re.add_argument("--all", action="store_true",
+                      help="Process every indexable catalog country (not only Hub gaps)")
+    p_re.add_argument("--force", action="store_true",
+                      help="Rebuild even when the source SHA matches (rerun normalize/verifiers)")
+
+    p_ver = sub.add_parser(
+        "verify",
+        help="Normalize a country pack and run admission verifiers (no GraphRAG)",
+    )
+    p_ver.add_argument("--source-repo", "--source", dest="source", default=None)
+    p_ver.add_argument("--all", action="store_true", help="Verify every indexable catalog country")
+    p_ver.add_argument("--limit", type=int, default=None)
 
     p_raw = sub.add_parser("package-raw")
     p_raw.add_argument("--slug", required=True, help="Country slug used in justicedao/ipfs_<slug>_laws_ir")
@@ -149,7 +163,7 @@ def main(argv: list[str] | None = None) -> int:
     if args.cmd == "reindex":
         from .build import reindex_from_gaps
 
-        cap = None if int(args.max_corpus_rows or 0) <= 0 else int(args.max_corpus_rows)
+        cap = None if args.all or int(args.max_corpus_rows or 0) <= 0 else int(args.max_corpus_rows)
         results = reindex_from_gaps(
             upload=args.upload,
             slugs=args.slugs or None,
@@ -158,6 +172,9 @@ def main(argv: list[str] | None = None) -> int:
             skip_vectors=args.skip_vectors,
             workers=args.workers,
             mode=args.mode,
+            force=args.force,
+            all_indexable=args.all,
+            device=args.device,
         )
         print(json.dumps(
             [
@@ -177,6 +194,65 @@ def main(argv: list[str] | None = None) -> int:
             default=str,
         ))
         return 1 if any(r.get("error") for r in results) else 0
+    if args.cmd == "verify":
+        from .catalog import indexable_countries
+        from .verify import verify_source
+
+        slugs = []
+        if args.all:
+            slugs = [c["slug"] for c in indexable_countries()]
+            if args.limit:
+                slugs = slugs[: int(args.limit)]
+        elif args.source:
+            slugs = [args.source]
+        else:
+            print(json.dumps({"error": "pass --source or --all"}, indent=2))
+            return 2
+        rows = []
+        failed = 0
+        for slug in slugs:
+            try:
+                row = verify_source(slug)
+            except Exception as exc:
+                row = {"slug": slug, "error": str(exc), "verification": {"admitted": False}}
+            rows.append(row)
+            if not (row.get("verification") or {}).get("admitted", False):
+                failed += 1
+        from collections import Counter
+
+        units = Counter(str(r.get("unit") or "") for r in rows)
+        mismatch = []
+        latin_blocked = []
+        for r in rows:
+            for chk in (r.get("verification") or {}).get("checks") or []:
+                if chk.get("id") != "heading_language":
+                    continue
+                ev = chk.get("evidence") or {}
+                if chk.get("severity") == "fail" and not chk.get("passed"):
+                    latin_blocked.append(r.get("slug"))
+                if "review samples" in str(chk.get("message") or ""):
+                    mismatch.append(
+                        {
+                            "slug": r.get("slug"),
+                            "document_language": ev.get("document_language"),
+                            "heading_language": ev.get("heading_language"),
+                        }
+                    )
+        print(
+            json.dumps(
+                {
+                    "n": len(rows),
+                    "n_failed": failed,
+                    "by_unit": dict(units),
+                    "heading_mismatch": mismatch,
+                    "latin_split_blocked": latin_blocked,
+                    "countries": rows,
+                },
+                indent=2,
+                default=str,
+            )
+        )
+        return 1 if failed else 0
     if args.cmd == "package-raw":
         from .build import RELEASES
         from .raw_package import default_instruments_dir, package_instruments

country_laws_ir/build.py

@@ -60,8 +60,17 @@ def _log(msg: str) -> None:
 def record_progress(event: dict[str, Any]) -> None:
     event = dict(event)
     event.setdefault("ts", datetime.now(timezone.utc).isoformat())
-    with PROGRESS.open("a", encoding="utf-8") as f:
-        f.write(json.dumps(event, ensure_ascii=False) + "\n")
+    PROGRESS.parent.mkdir(parents=True, exist_ok=True)
+    lock_path = PROGRESS.with_suffix(".lock")
+    with lock_path.open("a", encoding="utf-8") as lock_fh:
+        try:
+            import fcntl
+
+            fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX)
+        except Exception:
+            pass
+        with PROGRESS.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(event, ensure_ascii=False) + "\n")
 
 
 def _prior_dir_for(
@@ -202,7 +211,11 @@ def build_country(
         )
     )
     plan = plan_rebuild(
-        mode=mode, source_meta=source_meta, prior=prior, force=force
+        mode=mode,
+        source_meta=source_meta,
+        prior=prior,
+        force=force,
+        rebuild_stub_vectors=not skip_vectors,
     )
     if plan.skip_build:
         _log(f"skip unchanged {country['slug']} rev={plan.source_revision}")
@@ -234,6 +247,13 @@ def build_country(
     )
     if corpus.empty:
         raise RuntimeError("Normalized corpus is empty; refusing to package")
+    verdict = (norm_report or {}).get("verification") or {}
+    if verdict.get("blocks_graphrag") and not force:
+        from .verify import NormalizationAdmissionError
+
+        raise NormalizationAdmissionError(
+            f"{country['slug']} failed normalization verifiers: {verdict.get('failed_ids')}"
+        )
 
     import gc
 
@@ -243,6 +263,7 @@ def build_country(
         prior=prior,
         current_corpus=corpus,
         force=force,
+        rebuild_stub_vectors=not skip_vectors,
     )
     _log(
         f"rebuild kind={plan.kind.value} reuse_embeddings={plan.reuse_embeddings} "
@@ -394,17 +415,29 @@ def reindex_from_gaps(
     skip_vectors: bool = False,
     workers: int = 4,
     mode: str = "auto",
+    force: bool = False,
+    all_indexable: bool = False,
+    device: str = "cuda",
 ) -> list[dict[str, Any]]:
-    """Scan Hub gaps and incrementally rebuild stale/missing country IR.
+    """Rebuild country IR. Default is Hub gaps; ``all_indexable`` processes every catalog country.
 
     Default cap skips huge corpora (Finland, Dominican Republic). Pass
     ``max_corpus_rows=None`` to include them.
     """
+    from .catalog import indexable_countries
     from .coverage import gap_report
 
     if slugs is None:
-        report = gap_report(workers=workers)
-        rows = [c for c in report["countries"] if c.get("rebuild")]
+        if all_indexable:
+            rows = [{"slug": c["slug"], "corpus_rows": 0} for c in indexable_countries()]
+            _log(f"reindex all indexable n={len(rows)}")
+        else:
+            report = gap_report(workers=workers)
+            rows = [c for c in report["countries"] if c.get("rebuild")]
+            _log(
+                f"reindex targets n={len(rows)} "
+                f"(from scan rebuild={len(report.get('rebuild') or [])})"
+            )
         rows.sort(key=lambda r: int(r.get("corpus_rows") or 0))
         if max_corpus_rows is not None:
             rows = [
@@ -415,33 +448,54 @@ def reindex_from_gaps(
         if limit is not None:
             rows = rows[: int(limit)]
         slugs = [str(r["slug"]) for r in rows]
-        _log(
-            f"reindex targets n={len(slugs)} "
-            f"(from scan rebuild={len(report.get('rebuild') or [])})"
+    kwargs = {
+        "upload": upload,
+        "mode": mode,
+        "force": force,
+        "skip_vectors": skip_vectors,
+        "fetch_hub_prior_ir": True,
+        "device": device,
+    }
+    n_workers = max(1, int(workers or 1))
+    _log(f"reindex parallel workers={n_workers} countries={len(slugs)} device=cuda")
+    import multiprocessing as mp
+    from concurrent.futures import ProcessPoolExecutor, as_completed
+
+    try:
+        mp.set_start_method("spawn", force=False)
+    except RuntimeError:
+        pass
+
+    results = [None] * len(slugs)
+    with ProcessPoolExecutor(max_workers=n_workers, max_tasks_per_child=1) as pool:
+        futs = {
+            pool.submit(_reindex_one_country, (slug, kwargs)): i
+            for i, slug in enumerate(slugs)
+        }
+        for fut in as_completed(futs):
+            idx = futs[fut]
+            slug = slugs[idx]
+            try:
+                results[idx] = fut.result()
+            except Exception as exc:
+                _log(f"FAILED {slug}: {exc}")
+                results[idx] = {"country": slug, "skipped": False, "error": str(exc)}
+    return [r for r in results if r is not None]
+
+
+def _reindex_one_country(item: tuple[str, dict[str, Any]]) -> dict[str, Any]:
+    slug, kwargs = item
+    _log(f"reindex start {slug}")
+    try:
+        return build_country(slug, **kwargs)
+    except Exception as exc:
+        _log(f"FAILED {slug}: {exc}")
+        record_progress(
+            {
+                "event": "failed",
+                "country": slug,
+                "error": str(exc),
+                "traceback": traceback.format_exc(),
+            }
         )
-    results: list[dict[str, Any]] = []
-    for slug in slugs:
-        _log(f"reindex start {slug}")
-        try:
-            results.append(
-                build_country(
-                    slug,
-                    upload=upload,
-                    mode=mode,
-                    skip_vectors=skip_vectors,
-                    fetch_hub_prior_ir=True,
-                )
-            )
-        except Exception as exc:
-            _log(f"FAILED {slug}: {exc}")
-            record_progress(
-                {
-                    "event": "failed",
-                    "country": slug,
-                    "error": str(exc),
-                    "traceback": traceback.format_exc(),
-                }
-            )
-            results.append({"country": slug, "skipped": False, "error": str(exc)})
-            continue
-    return results
+        return {"country": slug, "skipped": False, "error": str(exc)}

country_laws_ir/citations.py

@@ -0,0 +1,147 @@
+"""Official and Bluebook citations for country-law corpus rows.
+
+Bluebook T2/T10 abbreviations are used only when this table has a row.
+Unknown jurisdictions get ``official_citation`` only — never a invented
+Bluebook form. Query keys are normalized so ``ORS 1.010`` and
+``Or. Rev. Stat. § 1.010`` can hit the same row later.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+import unicodedata
+from typing import Any
+
+# slug or country name (lower) -> Bluebook T2/T10 statute abbreviation.
+# Empty pinpoint templates are filled with article/section when present.
+_BLUEBOOK_STATUTE: dict[str, str] = {
+    "australia": "Cth",
+    "canada": "S.C.",
+    "united kingdom": "U.K.",
+    "uk": "U.K.",
+    "united states": "U.S.C.",
+    "usa": "U.S.C.",
+    "germany": "BGBl.",
+    "france": "J.O.",
+    "malta": "Laws of Malta",
+    "ireland": "Ir.",
+    "newzealand": "N.Z.",
+    "new zealand": "N.Z.",
+    "southafrica": "S. Afr.",
+    "south africa": "S. Afr.",
+    "india": "India",
+    "japan": "Japan",
+    "china": "P.R.C.",
+    "netherlands": "Stb.",
+    "austria": "BGBl.",
+    "switzerland": "AS",
+    "sweden": "SFS",
+    "norway": "Norsk Lovtidend",
+    "denmark": "Lovtidende",
+    "finland": "Finlex",
+    "eu": "O.J.",
+}
+
+
+@dataclass(frozen=True)
+class Citation:
+    official_citation: str
+    bluebook_citation: str
+    cite_key: str
+    citation_status: str  # bluebook | official_only | unknown
+    pinpoint: str
+
+
+def normalize_cite_key(value: str) -> str:
+    if not value:
+        return ""
+    text = unicodedata.normalize("NFKC", value).lower()
+    text = text.replace("§", " s ")
+    text = text.replace("¶", " ")
+    text = re.sub(r"\bart(?:icle|\.)?\b", "art", text)
+    text = re.sub(r"\bsec(?:tion|\.)?\b", "s", text)
+    text = re.sub(r"[^a-z0-9]+", " ", text)
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def _pinpoint(article_number: str, section_number: str, record_type: str) -> str:
+    if record_type == "section" and section_number:
+        return f"§ {section_number}"
+    if article_number:
+        return f"art. {article_number}"
+    if section_number:
+        return f"§ {section_number}"
+    return ""
+
+
+def _bluebook_abbrev(jurisdiction: str, country: str, slug: str = "") -> str:
+    for key in (slug, country, jurisdiction):
+        hit = _BLUEBOOK_STATUTE.get(str(key or "").strip().lower().replace("_", " "))
+        if hit:
+            return hit
+    return ""
+
+
+def assign_citation(
+    *,
+    eli: str = "",
+    official_identifier: str = "",
+    identifier: str = "",
+    instrument_title: str = "",
+    article_number: str = "",
+    section_number: str = "",
+    record_type: str = "law",
+    jurisdiction: str = "",
+    country: str = "",
+    slug: str = "",
+    year: str = "",
+) -> Citation:
+    pinpoint = _pinpoint(article_number, section_number, record_type)
+    official = (
+        (eli or "").strip()
+        or (official_identifier or "").strip()
+        or (identifier or "").strip()
+        or (instrument_title or "").strip()
+    )
+    if official and pinpoint and pinpoint.lower() not in official.lower():
+        official_cite = f"{official}, {pinpoint}"
+    else:
+        official_cite = official
+
+    abbrev = _bluebook_abbrev(jurisdiction, country, slug)
+    bluebook = ""
+    if abbrev and official:
+        if pinpoint:
+            if year:
+                bluebook = f"{abbrev} {pinpoint} ({year})"
+            else:
+                bluebook = f"{abbrev} {pinpoint}"
+        else:
+            bluebook = f"{abbrev} {official}" if official != abbrev else abbrev
+
+    if bluebook:
+        status = "bluebook"
+    elif official_cite:
+        status = "official_only"
+    else:
+        status = "unknown"
+
+    key_src = bluebook or official_cite
+    return Citation(
+        official_citation=official_cite,
+        bluebook_citation=bluebook,
+        cite_key=normalize_cite_key(key_src),
+        citation_status=status,
+        pinpoint=pinpoint,
+    )
+
+
+def citation_fields(cite: Citation) -> dict[str, Any]:
+    return {
+        "official_citation": cite.official_citation,
+        "bluebook_citation": cite.bluebook_citation,
+        "cite_key": cite.cite_key,
+        "citation_status": cite.citation_status,
+        "pinpoint": cite.pinpoint,
+    }

country_laws_ir/duckdb_store.py

@@ -151,6 +151,73 @@ def bm25_search(root: Path, query: str, top_k: int = 10) -> list[dict[str, Any]]
         con.close()
 
 
+def cite_search(
+    root: Path,
+    citation: str,
+    *,
+    cite_format: str = "any",
+    limit: int = 25,
+) -> list[dict[str, Any]]:
+    """Look up corpus rows by Bluebook, official cite, or normalized cite_key."""
+    from .citations import normalize_cite_key
+
+    needle = (citation or "").strip()
+    if not needle:
+        return []
+    key = normalize_cite_key(needle)
+    con = connect_release(root)
+    try:
+        tables = {
+            r[0]
+            for r in con.execute(
+                "SELECT table_name FROM information_schema.tables WHERE table_schema = 'main'"
+            ).fetchall()
+        }
+        if "corpus" not in tables:
+            raise DuckDBStoreError("release is missing corpus parquet shards")
+        cols = [
+            r[1]
+            for r in con.execute(
+                "SELECT table_schema, column_name FROM information_schema.columns "
+                "WHERE table_schema = 'main' AND table_name = 'corpus'"
+            ).fetchall()
+        ]
+        wanted = [
+            "entry_cid",
+            "record_type",
+            "title",
+            "instrument_title",
+            "article_number",
+            "official_citation",
+            "bluebook_citation",
+            "cite_key",
+            "citation_status",
+            "source_url",
+        ]
+        select = ", ".join(c for c in wanted if c in cols) or "*"
+        clauses = []
+        params: list[Any] = []
+        fmt = (cite_format or "any").strip().lower()
+        if fmt in {"any", "bluebook"} and "bluebook_citation" in cols:
+            clauses.append("lower(coalesce(bluebook_citation, '')) = lower(?)")
+            params.append(needle)
+        if fmt in {"any", "official"} and "official_citation" in cols:
+            clauses.append("lower(coalesce(official_citation, '')) = lower(?)")
+            params.append(needle)
+        if "cite_key" in cols and key:
+            clauses.append("cite_key = ?")
+            params.append(key)
+        if not clauses:
+            return []
+        sql = f"SELECT {select} FROM corpus WHERE {' OR '.join(clauses)} LIMIT ?"
+        params.append(int(limit))
+        rows = con.execute(sql, params).fetchall()
+        names = [c for c in wanted if c in cols] if select != "*" else list(cols)
+        return [dict(zip(names, row)) for row in rows]
+    finally:
+        con.close()
+
+
 def graph_neighbors(
     root: Path,
     node_cid: str,

country_laws_ir/incremental.py

@@ -234,6 +234,7 @@ def plan_rebuild(
     prior: PriorRelease | None,
     current_corpus: pd.DataFrame | None = None,
     force: bool = False,
+    rebuild_stub_vectors: bool = True,
 ) -> RebuildPlan:
     """Decide skip / delta / full from source fingerprints and CID overlap."""
     mode = BuildMode.coerce(mode)
@@ -280,7 +281,7 @@ def plan_rebuild(
         or ((prior.manifest.get("incremental") or {}).get("vectors") or {}).get("status")
         or ""
     ).strip().lower()
-    stub_vectors = prior_vector_status in {
+    stub_vectors = rebuild_stub_vectors and prior_vector_status in {
         "stub",
         "stub_missing_encoder",
         "incomplete",

country_laws_ir/normalize.py

@@ -1,8 +1,9 @@
 """Normalize endomorphosis/ipfs_*_laws into a CID-keyed canonical corpus.
 
 Prefer article/section as the retrieval unit; fall back to law-level when
-articles are missing or empty. Normalize (NFKC + whitespace collapse) BEFORE
-GraphRAG. Never invent legal text or identifiers.
+articles are missing or empty. Strip leftover HTML, then detect multilingual
+title/chapter/article/section headings (Oregon-style) when present. Never
+invent legal text or a hierarchy that is not in the source.
 
 Public Hub reads only (token=False). No Hugging Face token is read or stored.
 """
@@ -11,8 +12,6 @@ from __future__ import annotations
 
 import json
 import os
-import re
-import unicodedata
 from collections import Counter
 from pathlib import Path
 from typing import Any
@@ -25,8 +24,8 @@ from . import ENTRY_IDENTITY_SCHEMA, LAW_IDENTITY_SCHEMA, SCHEMA_VERSION
 from .auth import configure_hf, public_token
 from .cidutil import cid_of_json, sha256_file, sha256_hex
 from .schema import SchemaError, validate_articles, validate_laws
+from .structure import normalize_legal_text, split_structured_units
 
-_WS_RE = re.compile(r"\s+", re.UNICODE)
 COLLECTOR_DEFAULT = "endomorphosis/ipfs_datasets_py"
 EMPTY_ARTICLE_COLUMNS = (
     "law_id",
@@ -48,9 +47,7 @@ def _empty_articles() -> pd.DataFrame:
 def normalize_text(value: Any) -> str:
     if value is None or (isinstance(value, float) and pd.isna(value)):
         return ""
-    text = unicodedata.normalize("NFKC", str(value))
-    text = _WS_RE.sub(" ", text).strip()
-    return text
+    return normalize_legal_text(value)
 
 
 def _s(value: Any) -> str:
@@ -285,6 +282,35 @@ def _snapshot_date(row: pd.Series, meta: dict[str, Any], source_meta: dict[str,
     return ""
 
 
+def _hierarchy_fields(
+    title: str, body: str, article_number: str, *, language: str = ""
+) -> dict[str, Any]:
+    """Best-effort hierarchy from a single already-split article/section body."""
+    units = split_structured_units(
+        f"{title}\n{body}" if title else body, language=language
+    )
+    if not units:
+        return {
+            "hierarchy_kind": "article" if article_number else "law",
+            "hierarchy_path": "",
+            "title_number": "",
+            "chapter_number": "",
+            "part_number": "",
+            "section_number": "",
+            "subsections": [],
+        }
+    unit = units[0]
+    return {
+        "hierarchy_kind": unit.kind,
+        "hierarchy_path": unit.hierarchy_path,
+        "title_number": unit.title_number,
+        "chapter_number": unit.chapter_number,
+        "part_number": unit.part_number,
+        "section_number": unit.section_number,
+        "subsections": list(unit.subsections),
+    }
+
+
 def _collector(meta: dict[str, Any], source_dataset: str) -> str:
     nested = meta.get("metadata") if isinstance(meta.get("metadata"), dict) else {}
     for blob in (meta, nested):
@@ -373,6 +399,34 @@ def _base_record(
     }
     if extra:
         rec.update(extra)
+    from .citations import assign_citation, citation_fields
+
+    slug = ""
+    if source_dataset.startswith("endomorphosis/ipfs_") and source_dataset.endswith("_laws"):
+        slug = source_dataset.split("ipfs_", 1)[1].removesuffix("_laws")
+    year = ""
+    if snapshot_date and len(snapshot_date) >= 4 and snapshot_date[:4].isdigit():
+        year = snapshot_date[:4]
+    extra = extra or {}
+    rec.update(
+        citation_fields(
+            assign_citation(
+                eli=str(rec.get("eli") or extra.get("eli") or ""),
+                official_identifier=str(
+                    rec.get("official_identifier") or extra.get("official_identifier") or ""
+                ),
+                identifier=str(rec.get("identifier") or extra.get("identifier") or ""),
+                instrument_title=instrument_title,
+                article_number=article_number,
+                section_number=str(extra.get("section_number") or ""),
+                record_type=record_type,
+                jurisdiction=jurisdiction,
+                country=str(extra.get("country") or ""),
+                slug=slug,
+                year=year,
+            )
+        )
+    )
     rec["entry_cid"] = _entry_cid(rec)
     rec["title_length"] = len(title_for_bm25)
     rec["body_length"] = len(body)
@@ -433,11 +487,62 @@ def build_corpus(
 
     entries: list[dict[str, Any]] = []
 
+    def _append_law_row(instrument_id: str, parent: dict[str, Any]) -> None:
+        body = parent["body"]
+        if not body:
+            report["drops"]["empty_body"] += 1
+            if len(report["drop_samples"]["empty_body"]) < 20:
+                report["drop_samples"]["empty_body"].append(instrument_id)
+            return
+        meta = parent["metadata"]
+        entries.append(
+            _base_record(
+                record_type="law",
+                source_dataset=source_dataset,
+                source_revision=source_revision,
+                instrument_id=instrument_id,
+                instrument_title=parent["instrument_title"],
+                law_cid=parent["law_cid"],
+                article_number="",
+                article_title="",
+                body=body,
+                jurisdiction=parent["jurisdiction"],
+                language=parent["language"],
+                source_url=parent["source_url"],
+                snapshot_date=_snapshot_date(parent["row"], meta, source_meta),
+                coverage=_coverage_from(
+                    parent["row"],
+                    meta,
+                    articles_empty=articles_empty,
+                    sparse_fallback=sparse_fallback,
+                ),
+                license_expr=parent["license"],
+                collector=_collector(meta, source_dataset),
+                source_id=instrument_id,
+                extra={
+                    "eli": parent["eli"],
+                    "identifier": parent["identifier"],
+                    "official_identifier": parent["official_identifier"],
+                    "source_type": parent["source_type"],
+                    "country": parent["country"],
+                    "law_status": parent["law_status"],
+                    "parent_law_id": "",
+                    "article_id": "",
+                    **_hierarchy_fields(
+                        parent["instrument_title"], body, "", language=parent["language"]
+                    ),
+                },
+            )
+        )
+
     if sparse_fallback:
         report["schema_surprises"].append(
             f"article coverage {article_law_coverage:.4f} < 0.10 of laws; falling back to law-level units"
         )
 
+    for instrument_id, parent in law_map.items():
+        _append_law_row(instrument_id, parent)
+
     if use_articles:
         for _, row in articles.iterrows():
             source_id = _row_get(row, "id")
@@ -489,6 +594,9 @@ def build_corpus(
                         "law_status": parent["law_status"],
                         "parent_law_id": instrument_id,
                         "article_id": source_id,
+                        **_hierarchy_fields(
+                            article_title, body, article_number, language=parent["language"]
+                        ),
                     },
                 )
             )
@@ -496,44 +604,50 @@ def build_corpus(
         for instrument_id, parent in law_map.items():
             body = parent["body"]
             if not body:
-                report["drops"]["empty_body"] += 1
-                if len(report["drop_samples"]["empty_body"]) < 20:
-                    report["drop_samples"]["empty_body"].append(instrument_id)
                 continue
             meta = parent["metadata"]
-            entries.append(
-                _base_record(
-                    record_type="law",
-                    source_dataset=source_dataset,
-                    source_revision=source_revision,
-                    instrument_id=instrument_id,
-                    instrument_title=parent["instrument_title"],
-                    law_cid=parent["law_cid"],
-                    article_number="",
-                    article_title="",
-                    body=body,
-                    jurisdiction=parent["jurisdiction"],
-                    language=parent["language"],
-                    source_url=parent["source_url"],
-                    snapshot_date=_snapshot_date(parent["row"], meta, source_meta),
-                    coverage=_coverage_from(
-                        parent["row"], meta, articles_empty=True, sparse_fallback=sparse_fallback
-                    ),
-                    license_expr=parent["license"],
-                    collector=_collector(meta, source_dataset),
-                    source_id=instrument_id,
-                    extra={
-                        "eli": parent["eli"],
-                        "identifier": parent["identifier"],
-                        "official_identifier": parent["official_identifier"],
-                        "source_type": parent["source_type"],
-                        "country": parent["country"],
-                        "law_status": parent["law_status"],
-                        "parent_law_id": "",
-                        "article_id": "",
-                    },
-                )
-            )
+            units = split_structured_units(body, language=parent["language"])
+            if units:
+                report["unit"] = "structured"
+                for unit in units:
+                    entries.append(
+                        _base_record(
+                            record_type=unit.kind if unit.kind in {"article", "section"} else "article",
+                            source_dataset=source_dataset,
+                            source_revision=source_revision,
+                            instrument_id=instrument_id,
+                            instrument_title=parent["instrument_title"],
+                            law_cid=parent["law_cid"],
+                            article_number=unit.article_number or unit.number,
+                            article_title=unit.heading,
+                            body=unit.body,
+                            jurisdiction=parent["jurisdiction"],
+                            language=parent["language"],
+                            source_url=parent["source_url"],
+                            snapshot_date=_snapshot_date(parent["row"], meta, source_meta),
+                            coverage="structured (headings detected in law body)",
+                            license_expr=parent["license"],
+                            collector=_collector(meta, source_dataset),
+                            source_id=f"{instrument_id}-{unit.kind}-{unit.number}",
+                            extra={
+                                "eli": parent["eli"],
+                                "identifier": parent["identifier"],
+                                "official_identifier": parent["official_identifier"],
+                                "source_type": parent["source_type"],
+                                "country": parent["country"],
+                                "law_status": parent["law_status"],
+                                "parent_law_id": instrument_id,
+                                "article_id": "",
+                                "hierarchy_kind": unit.kind,
+                                "hierarchy_path": unit.hierarchy_path,
+                                "title_number": unit.title_number,
+                                "chapter_number": unit.chapter_number,
+                                "part_number": unit.part_number,
+                                "section_number": unit.section_number,
+                                "subsections": list(unit.subsections),
+                            },
+                        )
+                    )
 
     entries.sort(
         key=lambda r: (
@@ -564,6 +678,20 @@ def build_corpus(
         raise SchemaError("Duplicate entry_cid remained after dedupe")
     report["n_before_dedupe"] = n_before
     report["n_out"] = int(len(df))
+    if not df.empty and "record_type" in df.columns:
+        n_law_rows = int((df["record_type"] == "law").sum())
+        n_child_rows = int(df["record_type"].isin(["article", "section"]).sum())
+        report["n_law_rows"] = n_law_rows
+        report["n_child_rows"] = n_child_rows
+        report["n_instruments"] = int(df["instrument_id"].nunique()) if "instrument_id" in df.columns else n_law_rows
+        if n_law_rows and n_child_rows:
+            report["unit"] = (
+                "law+structured" if report.get("unit") == "structured" else "law+article"
+            )
+        elif n_law_rows:
+            report["unit"] = "law"
+        elif n_child_rows:
+            report["unit"] = "article"
     report["n_dropped_total"] = (
         report["drops"]["empty_body"]
         + report["drops"]["missing_instrument"]
@@ -607,5 +735,23 @@ def build_corpus(
         "empty_bodies_dropped": report["drops"]["empty_body"],
         "duplicate_cids_dropped": report["drops"]["duplicate_cid"],
     }
+    from .profiles import majority_language, score_heading_languages
+
+    sample_text = ""
+    if not df.empty and "body" in df.columns:
+        sample_text = "\n".join(str(x) for x in df["body"].head(40).tolist())
+        if "title" in df.columns:
+            sample_text = "\n".join(str(x) for x in df["title"].head(40).tolist()) + "\n" + sample_text
+    heading_langs = score_heading_languages(sample_text)
+    report["heading_language_counts"] = dict(heading_langs)
+    report["heading_language_majority"] = majority_language(heading_langs)
+    report["document_language_majority"] = None
+    if report.get("language_breakdown"):
+        report["document_language_majority"] = max(
+            report["language_breakdown"].items(), key=lambda kv: kv[1]
+        )[0]
+    from .verify import verify_normalized_corpus
+
+    report["verification"] = verify_normalized_corpus(df, report)
     df.attrs["normalization_report"] = report
     return df, report

country_laws_ir/profiles.py

@@ -0,0 +1,124 @@
+"""Per-language legal heading lexicons for country-law structure extraction.
+
+Oregon (ORS) is English title/chapter/section. Other gazettes use their own
+words (Artikel, Titre, Artículo, 条, مادة). This table is how we *score*
+whether a split used the right language — not a claim that every country
+has a dedicated parser.
+
+Languages with no lexicon (ar, zh, ja, ko, …) must not be force-split on
+Latin TITLE/ARTICLE markers; collectors may already have article rows.
+"""
+
+from __future__ import annotations
+
+from collections import Counter
+import re
+from typing import Any
+
+# keyword -> list of (kind, language); some words are shared (article).
+HEADING_LEXICON: dict[str, list[tuple[str, str]]] = {}
+
+def _add(lang: str, kind: str, *words: str) -> None:
+    for word in words:
+        HEADING_LEXICON.setdefault(word.casefold(), []).append((kind, lang))
+
+
+_add("en", "title", "title")
+_add("en", "chapter", "chapter")
+_add("en", "part", "part")
+_add("en", "article", "article")
+_add("en", "section", "section", "sec.")
+
+_add("fr", "title", "titre")
+_add("fr", "chapter", "chapitre")
+_add("fr", "part", "partie")
+_add("fr", "article", "article")
+_add("fr", "section", "section")
+
+_add("de", "title", "titel")
+_add("de", "chapter", "kapitel")
+_add("de", "part", "teil")
+_add("de", "article", "artikel")
+_add("de", "section", "abschnitt", "paragraf")
+
+_add("nl", "title", "titel")
+_add("nl", "chapter", "hoofdstuk")
+_add("nl", "part", "deel")
+_add("nl", "article", "artikel")
+_add("nl", "section", "paragraaf", "afdeling")
+
+_add("es", "title", "título", "titulo")
+_add("es", "chapter", "capítulo", "capitulo")
+_add("es", "part", "parte")
+_add("es", "article", "artículo", "articulo")
+_add("es", "section", "sección", "seccion")
+
+_add("pt", "title", "título", "titulo")
+_add("pt", "chapter", "capítulo", "capitulo")
+_add("pt", "part", "parte")
+_add("pt", "article", "artigo")
+_add("pt", "section", "secção", "secao")
+
+_add("it", "title", "titolo")
+_add("it", "chapter", "capitolo")
+_add("it", "part", "parte")
+_add("it", "article", "articolo")
+_add("it", "section", "sezione")
+
+_add("el", "article", "άρθρο", "αρθρο")
+_add("hu", "article", "szakasz")
+_add("cs", "article", "článek")
+_add("sk", "article", "článok")
+_add("sl", "article", "član")
+_add("nb", "article", "artikkel")
+_add("sv", "article", "artikel")
+_add("pl", "article", "artykuł", "artykul")
+_add("ro", "article", "articolul", "articol")
+_add("zh", "article", "条")
+_add("ar", "article", "مادة", "المادة")
+_add("ja", "article", "条")
+
+# Shared abbreviation; language left unknown.
+_add("und", "article", "art.")
+_add("und", "section", "§")
+
+# Scripts we do not Latin-split:
+NO_LATIN_SPLIT_LANGS = frozenset({"ar", "zh", "zh-cn", "zh-tw", "ja", "ko", "fa", "he", "th", "hi", "bn", "am"})
+
+_TOKEN_RE = re.compile(r"[^\W\d_]{2,}|art\.|sec\.|§", re.UNICODE)
+
+
+def classify_heading_token(token: str) -> list[tuple[str, str]]:
+    return list(HEADING_LEXICON.get(token.casefold()) or ())
+
+
+def score_heading_languages(text: str) -> Counter[str]:
+    """Count distinctive lexicon hits. Shared words like 'article' do not vote."""
+    counts: Counter[str] = Counter()
+    if not text:
+        return counts
+    for token in _TOKEN_RE.findall(text):
+        hits = classify_heading_token(token)
+        langs = {lang for _kind, lang in hits if lang != "und"}
+        if len(langs) == 1:
+            counts[next(iter(langs))] += 1
+    return counts
+
+
+def majority_language(counts: Counter[str], *, exclude: tuple[str, ...] = ("und",)) -> str | None:
+    filtered = Counter({k: v for k, v in counts.items() if k not in exclude})
+    if not filtered:
+        return None
+    lang, _n = filtered.most_common(1)[0]
+    return lang
+
+
+def iso_lang(value: Any) -> str:
+    text = str(value or "").strip().lower().replace("_", "-")
+    if not text:
+        return ""
+    return text.split("-")[0]
+
+
+def latin_split_allowed(language: str) -> bool:
+    return iso_lang(language) not in NO_LATIN_SPLIT_LANGS

country_laws_ir/query.py

@@ -158,6 +158,11 @@ class Release:
         hits.sort(key=lambda r: (-(r["score"] or 0), r["neighbor_cid"]))
         return hits[:limit]
 
+    def cite(self, citation: str, cite_format: str = "any", limit: int = 25) -> list[dict]:
+        from .duckdb_store import cite_search
+
+        return cite_search(self.root, citation, cite_format=cite_format, limit=limit)
+
 
 def _print(rows: list[dict]) -> None:
     print(json.dumps(rows, indent=2, ensure_ascii=False))
@@ -189,6 +194,16 @@ def main(argv: list[str] | None = None) -> int:
     )
     p_n.add_argument("--limit", type=int, default=25)
 
+    p_cite = sub.add_parser("cite")
+    p_cite.add_argument("citation")
+    p_cite.add_argument(
+        "--format",
+        dest="cite_format",
+        default="any",
+        choices=["any", "bluebook", "official"],
+    )
+    p_cite.add_argument("--limit", type=int, default=25)
+
     args = ap.parse_args(argv)
     rel = Release(Path(args.local_dir))
     if args.cmd == "bm25":
@@ -197,6 +212,8 @@ def main(argv: list[str] | None = None) -> int:
         _print(rel.vector(args.query, top_k=args.top_k, candidate_centroids=args.candidate_centroids, device=args.device))
     elif args.cmd == "graph" and args.graph_cmd == "neighbors":
         _print(rel.neighbors(args.node_cid, direction=args.direction, limit=args.limit))
+    elif args.cmd == "cite":
+        _print(rel.cite(args.citation, cite_format=args.cite_format, limit=args.limit))
     return 0
 
 

country_laws_ir/sparse.py

@@ -31,10 +31,18 @@ def corpus_to_bm25_rows(corpus: pd.DataFrame) -> list[dict[str, Any]]:
     """
     from ipfs_datasets_py.retrieval.hf_graphrag.bm25 import tokenize_bm25_text
 
+    _MAX_TITLE = 8_192
+    _MAX_BODY = 200_000
     rows: list[dict[str, Any]] = []
     for rec in corpus.itertuples(index=False):
-        title = str(getattr(rec, "title", "") or "")
-        body = str(getattr(rec, "body", "") or "")
+        title = str(getattr(rec, "title", "") or "").replace("\x00", "").strip()
+        body = str(getattr(rec, "body", "") or "").replace("\x00", "").strip()
+        if len(title) > _MAX_TITLE:
+            title = title[:_MAX_TITLE].rstrip()
+        if len(body) > _MAX_BODY:
+            body = body[:_MAX_BODY].rstrip()
+        if not title and not body:
+            continue
         if not tokenize_bm25_text(title) and not tokenize_bm25_text(body):
             continue
         rows.append(

country_laws_ir/structure.py

@@ -0,0 +1,305 @@
+"""Extract legal hierarchy from country-law text (Oregon-style, multilingual).
+
+Oregon Revised Statutes are stored as title / chapter / section / subsection
+trees. National gazettes are not that uniform: some use Article/Artikel,
+some §, some only a single instrument body.
+
+This module:
+
+* strips leftover HTML chrome so GraphRAG sees legal text, not tags;
+* detects multilingual heading markers (title/chapter/part/article/section);
+* splits an instrument into those units when at least two headings exist;
+* otherwise keeps the whole instrument (never invents a hierarchy).
+
+Subsection markers such as ``(a)`` / ``(1)`` are recorded on the parent
+unit; they are not forced into their own retrieval rows.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from html.parser import HTMLParser
+import html as html_lib
+import re
+import unicodedata
+from typing import Any
+
+_WS_RE = re.compile(r"\s+", re.UNICODE)
+_HAS_TAG_RE = re.compile(r"</?[a-zA-Z][^>]*>")
+
+# Line-anchored headings. Numbers may be arabic, roman, or dotted (1.2).
+_HEADING_RE = re.compile(
+    r"(?im)^[ \t]*(?:"
+    r"(?P<title>TITLE|TITRE|TITEL|T[IÍ]TULO|TITOLO|T[IÍ]TUL)\s+"
+    r"(?P<title_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)"
+    r"|(?P<chapter>CHAPTER|CHAPITRE|KAPITEL|CAP[IÍ]TULO|CAPITOLO|HOOFDSTUK|CAP\.)\s+"
+    r"(?P<chapter_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)"
+    r"|(?P<part>PART|PARTIE|TEIL|PARTE|DEEL)\s+"
+    r"(?P<part_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)"
+    r"|(?P<article>ART(?:ICLE|IKEL|ÍCULO|IGO|ICOLO|IKKEL)?\.?|ART\."
+    r"|ČLÁNEK|ČLÁNOK|ČLAN|SZAKASZ|ΆΡΘΡΟ|ΑΡΘΡΟ)\s+"
+    r"(?P<article_n>[0-9IVXLCDMΑ-Ω]+[A-Za-zΑ-Ωa-z0-9.\-]*)"
+    r"|(?P<section>SECTION|SECCI[OÓ]N|SEZIONE|ABSCHNITT|SEC\.)\s+"
+    r"(?P<section_n>[0-9A-Za-z.\-]+)"
+    r"|(?P<section_sym>§+)\s*(?P<section_sym_n>[0-9A-Za-z.\-]+)"
+    r")"
+    r"(?P<rest>[^\n]{0,200})?"
+)
+
+_SUBSECTION_RE = re.compile(r"\(([0-9A-Za-z]{1,6})\)")
+
+_KIND_RANK = {
+    "title": 1,
+    "chapter": 2,
+    "part": 3,
+    "article": 4,
+    "section": 5,
+    "subsection": 6,
+}
+
+MIN_SPLIT_HEADINGS = 2
+MIN_UNIT_CHARS = 40
+
+_ZH_ART_RE = re.compile(
+    r"(?:(?<=\n)|^)[ 　]*"
+    r"(第[一二三四五六七八九十百千万零〇两0-9]+条(?:之[一二三四五六七八九十百0-9]+)?)"
+)
+_AR_ART_RE = re.compile(
+    r"(?:(?<=\n)|^)[ \t]*(المادة|مادة)\s*([0-9٠-٩]+)"
+)
+_JA_ART_RE = re.compile(
+    r"(?:(?<=\n)|^)[ 　]*(第[0-9一二三四五六七八九十百]+条)"
+)
+
+
+class _HTMLText(HTMLParser):
+    SKIP = {"script", "style", "noscript", "svg", "nav", "footer", "header"}
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.parts: list[str] = []
+        self.skip = 0
+
+    def handle_starttag(self, tag, attrs):
+        if tag in self.SKIP:
+            self.skip += 1
+        if tag in {"br", "p", "tr", "div", "li", "h1", "h2", "h3"} and self.skip == 0:
+            self.parts.append("\n")
+
+    def handle_endtag(self, tag):
+        if tag in self.SKIP and self.skip:
+            self.skip -= 1
+        if tag in {"p", "div", "li", "tr"} and self.skip == 0:
+            self.parts.append("\n")
+
+    def handle_data(self, data):
+        if self.skip == 0:
+            self.parts.append(data)
+
+
+def has_html_tags(text: str) -> bool:
+    return bool(text and _HAS_TAG_RE.search(text))
+
+
+def strip_html(raw: str) -> str:
+    """Turn leftover HTML into visible legal text. No-op if there are no tags."""
+    if not raw or not _HAS_TAG_RE.search(raw):
+        return raw
+    parser = _HTMLText()
+    try:
+        parser.feed(raw)
+        parser.close()
+        text = "".join(parser.parts)
+    except Exception:
+        text = re.sub(r"(?is)<script.*?>.*?</script>", " ", raw)
+        text = re.sub(r"(?is)<style.*?>.*?</style>", " ", text)
+        text = re.sub(r"(?is)<[^>]+>", " ", text)
+    text = html_lib.unescape(text).replace("\xa0", " ")
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n[ \t]+", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def normalize_legal_text(value: Any) -> str:
+    """NFKC + HTML strip. Keeps newlines so heading detection still works."""
+    if value is None:
+        return ""
+    text = unicodedata.normalize("NFKC", str(value))
+    text = strip_html(text)
+    text = text.replace("\xa0", " ")
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n[ \t]+", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+@dataclass
+class StructureUnit:
+    kind: str
+    number: str
+    heading: str
+    body: str
+    title_number: str = ""
+    chapter_number: str = ""
+    part_number: str = ""
+    article_number: str = ""
+    section_number: str = ""
+    subsections: tuple[str, ...] = ()
+    hierarchy_path: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "kind": self.kind,
+            "number": self.number,
+            "heading": self.heading,
+            "body": self.body,
+            "title_number": self.title_number,
+            "chapter_number": self.chapter_number,
+            "part_number": self.part_number,
+            "article_number": self.article_number,
+            "section_number": self.section_number,
+            "subsections": list(self.subsections),
+            "hierarchy_path": self.hierarchy_path,
+        }
+
+
+def _cursor_path(cursor: dict[str, str]) -> str:
+    parts = []
+    for key, label in (
+        ("title", "Title"),
+        ("chapter", "Chapter"),
+        ("part", "Part"),
+        ("article", "Article"),
+        ("section", "Section"),
+    ):
+        value = cursor.get(key) or ""
+        if value:
+            parts.append(f"{label} {value}")
+    return " > ".join(parts)
+
+
+def _subsection_tokens(text: str) -> tuple[str, ...]:
+    seen: list[str] = []
+    for match in _SUBSECTION_RE.finditer(text):
+        token = match.group(1)
+        if token not in seen:
+            seen.append(token)
+        if len(seen) >= 40:
+            break
+    return tuple(seen)
+
+
+def _units_from_regex(
+    text: str, matches: list[re.Match[str]], *, kind: str, lang: str
+) -> list[StructureUnit]:
+    if len(matches) < MIN_SPLIT_HEADINGS:
+        return []
+    units: list[StructureUnit] = []
+    for i, match in enumerate(matches):
+        start = match.start()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        chunk = text[start:end].strip()
+        if len(chunk) < 16:
+            continue
+        number = re.sub(r"\s+", "", match.group(0))
+        heading = re.sub(r"\s+", " ", chunk.split("\n", 1)[0])[:240]
+        units.append(
+            StructureUnit(
+                kind=kind,
+                number=number,
+                heading=heading,
+                body=chunk,
+                article_number=number,
+                hierarchy_path=heading,
+            )
+        )
+    return units if len(units) >= MIN_SPLIT_HEADINGS else []
+
+
+def split_script_units(text: str, language: str) -> list[StructureUnit]:
+    """Article splits for scripts that must not use Latin TITLE/ARTICLE."""
+    from .profiles import iso_lang
+
+    lang = iso_lang(language)
+    if lang in {"zh", "zh-cn", "zh-tw"}:
+        prepared = re.sub(
+            r"(第[一二三四五六七八九十百千万零〇两0-9]+条(?:之[一二三四五六七八九十百0-9]+)?)",
+            r"\n\1",
+            text,
+        )
+        return _units_from_regex(prepared, list(_ZH_ART_RE.finditer(prepared)), kind="article", lang="zh")
+    if lang in {"ar", "fa"}:
+        prepared = re.sub(r"(المادة|مادة)", r"\n\1", text)
+        return _units_from_regex(prepared, list(_AR_ART_RE.finditer(prepared)), kind="article", lang="ar")
+    if lang == "ja":
+        prepared = re.sub(r"(第[0-9一二三四五六七八九十百]+条)", r"\n\1", text)
+        return _units_from_regex(prepared, list(_JA_ART_RE.finditer(prepared)), kind="article", lang="ja")
+    return []
+
+
+def split_structured_units(text: str, *, language: str = "") -> list[StructureUnit]:
+    """Split *text* on legal headings. Empty list means keep the whole instrument.
+
+    Latin TITLE/ARTICLE splits are skipped for languages in
+    ``profiles.NO_LATIN_SPLIT_LANGS`` so Arabic/Chinese bodies are not
+    carved up on incidental English words.
+    """
+    from .profiles import latin_split_allowed
+
+    if not text or len(text) < 16:
+        return []
+    if language and not latin_split_allowed(language):
+        return split_script_units(text, language)
+    matches = list(_HEADING_RE.finditer(text))
+    if len(matches) < MIN_SPLIT_HEADINGS:
+        return []
+    cursor = {"title": "", "chapter": "", "part": "", "article": "", "section": ""}
+    units: list[StructureUnit] = []
+    for i, match in enumerate(matches):
+        start = match.start()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        chunk = text[start:end].strip()
+        kind = ""
+        number = ""
+        for name in ("title", "chapter", "part", "article", "section"):
+            if match.group(name):
+                kind = name
+                number = (match.group(f"{name}_n") or "").strip()
+                break
+        if match.group("section_sym"):
+            kind = "section"
+            number = (match.group("section_sym_n") or "").strip()
+        if not kind or not number:
+            continue
+        cursor[kind] = number
+        for lower, rank in _KIND_RANK.items():
+            if rank > _KIND_RANK[kind]:
+                cursor[lower] = ""
+        if len(chunk) < MIN_UNIT_CHARS:
+            continue
+        rest = (match.group("rest") or "").strip(" .-:")
+        heading = re.sub(r"\s+", " ", match.group(0)).strip()
+        if rest and rest not in heading:
+            heading = f"{heading} {rest}".strip()
+        units.append(
+            StructureUnit(
+                kind=kind,
+                number=number,
+                heading=heading[:240],
+                body=chunk,
+                title_number=cursor["title"],
+                chapter_number=cursor["chapter"],
+                part_number=cursor["part"],
+                article_number=cursor["article"],
+                section_number=cursor["section"],
+                subsections=_subsection_tokens(chunk),
+                hierarchy_path=_cursor_path(cursor),
+            )
+        )
+    retrieval = [u for u in units if u.kind in {"article", "section"}]
+    if len(retrieval) >= MIN_SPLIT_HEADINGS:
+        return retrieval
+    if len(units) >= MIN_SPLIT_HEADINGS:
+        return units
+    return []

country_laws_ir/vectors.py

@@ -130,13 +130,6 @@ def encode_corpus(
 
     configure_hf()
     device, _fallback = select_device(device)
-    cache_root = _Path(os.environ.get("COUNTRY_LAWS_IR_ROOT", str(_Path.home() / ".ipfs_datasets" / "country-laws-ir"))) / "cache" / "hf"
-    os.environ.setdefault("HF_HOME", str(cache_root))
-    os.environ.setdefault("HF_HUB_DISABLE_IMPLICIT_TOKEN", "1")
-    os.environ.setdefault(
-        "SENTENCE_TRANSFORMERS_HOME",
-        str(cache_root / "sentence-transformers"),
-    )
     texts = []
     for rec in corpus.itertuples(index=False):
         title = getattr(rec, "title", None) or getattr(rec, "instrument_title", "") or ""
@@ -148,12 +141,22 @@ def encode_corpus(
     done = 0
     ckpt = _Path(checkpoint_path) if checkpoint_path else None
     meta_path = ckpt.with_suffix(".json") if ckpt else None
-    meta_n = None
+    cache_root = _Path(
+        os.environ.get(
+            "COUNTRY_LAWS_IR_ROOT",
+            str(_Path.home() / ".ipfs_datasets" / "country-laws-ir"),
+        )
+    ) / "cache" / "hf"
+    os.environ.setdefault("HF_HOME", str(cache_root))
+    os.environ.setdefault("HF_HUB_DISABLE_IMPLICIT_TOKEN", "1")
+    os.environ.setdefault("SENTENCE_TRANSFORMERS_HOME", str(cache_root / "sentence-transformers"))
     if meta_path is not None and meta_path.exists():
         try:
             meta_n = json.loads(meta_path.read_text(encoding="utf-8")).get("n")
         except Exception:
             meta_n = None
+    else:
+        meta_n = None
     if ckpt is not None and ckpt.exists():
         cached = np.load(ckpt)
         same_corpus = meta_n is None or int(meta_n) == n
@@ -165,64 +168,76 @@ def encode_corpus(
         ):
             done = int(cached.shape[0])
             out[:done] = cached.astype(np.float32, copy=False)
-            print(f"embeddings resume {done}/{n} from {ckpt}", flush=True)
-        else:
-            print(
-                f"embeddings checkpoint shape {getattr(cached, 'shape', None)} "
-                f"meta_n={meta_n} incompatible with {(n, DIMENSION)}; restarting",
-                flush=True,
+        if done >= n:
+            return out
+
+    lock_fh = None
+    if device.startswith("cuda"):
+        import fcntl
+
+        lock_path = _Path(
+            os.environ.get(
+                "COUNTRY_LAWS_IR_ROOT",
+                str(_Path.home() / ".ipfs_datasets" / "country-laws-ir"),
             )
-    if done >= n:
-        return out
-    model = SentenceTransformer(
-        MODEL_NAME,
-        revision=MODEL_REVISION,
-        device=device,
-    )
+        ) / "cuda.encode.lock"
+        lock_path.parent.mkdir(parents=True, exist_ok=True)
+        lock_fh = open(lock_path, "a", encoding="utf-8")
+        fcntl.flock(lock_fh.fileno(), fcntl.LOCK_EX)
     try:
-        model.max_seq_length = MAX_SEQ_LENGTH
-    except Exception:
-        pass
-    while done < n:
-        j = min(done + int(chunk_size), n)
-        chunk = model.encode(
-            texts[done:j],
-            batch_size=batch_size,
-            show_progress_bar=True,
-            convert_to_numpy=True,
-            normalize_embeddings=True,
+        model = SentenceTransformer(
+            MODEL_NAME,
+            revision=MODEL_REVISION,
+            device=device,
         )
-        out[done:j] = np.asarray(chunk, dtype=np.float32)
-        done = j
-        print(f"embeddings checkpoint {done}/{n}", flush=True)
         try:
-            from .mem import checkpoint as _mem_checkpoint
-            _mem_checkpoint(f"embeddings@{done}", row=done, every_n=max(chunk_size, 4096))
-        except Exception as _mem_exc:
-            # MemAbort should propagate; other import issues are non-fatal
-            from .mem import MemAbort
-            if isinstance(_mem_exc, MemAbort):
-                raise
-        if ckpt is not None:
-            ckpt.parent.mkdir(parents=True, exist_ok=True)
-            tmp = ckpt.with_name(ckpt.name + ".tmp.npy")
-            np.save(tmp, out[:done])
-            tmp.replace(ckpt)
-            if meta_path is not None:
-                meta_path.write_text(
-                    json.dumps(
-                        {
-                            "n": n,
-                            "done": done,
-                            "dimension": DIMENSION,
-                            "model_name": MODEL_NAME,
-                            "ts": datetime.now(timezone.utc).isoformat(),
-                        }
+            model.max_seq_length = MAX_SEQ_LENGTH
+        except Exception:
+            pass
+        while done < n:
+            j = min(done + int(chunk_size), n)
+            chunk = model.encode(
+                texts[done:j],
+                batch_size=batch_size,
+                show_progress_bar=True,
+                convert_to_numpy=True,
+                normalize_embeddings=True,
+            )
+            out[done:j] = np.asarray(chunk, dtype=np.float32)
+            done = j
+            if ckpt is not None:
+                ckpt.parent.mkdir(parents=True, exist_ok=True)
+                tmp = ckpt.with_name(ckpt.name + ".tmp.npy")
+                np.save(tmp, out[:done])
+                tmp.replace(ckpt)
+                if meta_path is not None:
+                    meta_path.write_text(
+                        json.dumps(
+                            {
+                                "n": n,
+                                "done": done,
+                                "dimension": DIMENSION,
+                                "model_name": MODEL_NAME,
+                                "ts": datetime.now(timezone.utc).isoformat(),
+                            }
+                        )
+                        + "\n",
+                        encoding="utf-8",
                     )
-                    + "\n",
-                    encoding="utf-8",
-                )
-    return out
+        return out
+    finally:
+        if lock_fh is not None:
+            import fcntl as _fcntl
+
+            _fcntl.flock(lock_fh.fileno(), _fcntl.LOCK_UN)
+            lock_fh.close()
+        try:
+            import torch as _torch
+
+            if _torch.cuda.is_available():
+                _torch.cuda.empty_cache()
+        except Exception:
+            pass
 
 
 def _spherical_kmeans(x: np.ndarray, k: int, iters: int = 12, seed: int = 0) -> np.ndarray:

country_laws_ir/verify.py

@@ -0,0 +1,308 @@
+"""Admission verifiers for country-law normalization, before GraphRAG.
+
+Oregon-style structure is preferred but not required for every gazette.
+Verifiers fail closed on invented text, residual HTML, empty corpora, and
+duplicate CIDs. Missing title/section hierarchy is a warning unless the
+corpus already split into articles.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+import re
+from typing import Any
+
+import pandas as pd
+
+from .structure import has_html_tags
+
+SCHEMA_VERSION = "country-laws-normalize-verify/v1"
+
+_HTML_FAIL_FRACTION = 0.02
+_SHORT_BODY_FAIL_FRACTION = 0.50
+_MIN_BODY_CHARS = 40
+
+
+@dataclass(frozen=True)
+class Check:
+    id: str
+    severity: str  # fail | warn
+    passed: bool
+    message: str
+    evidence: dict[str, Any]
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+def _bodies(corpus: pd.DataFrame) -> list[str]:
+    if corpus is None or corpus.empty or "body" not in corpus.columns:
+        return []
+    return [str(x or "") for x in corpus["body"].tolist()]
+
+
+def check_nonempty(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    n = int(len(corpus)) if corpus is not None else 0
+    return Check(
+        id="nonempty_corpus",
+        severity="fail",
+        passed=n > 0,
+        message="normalized corpus has rows" if n else "normalized corpus is empty",
+        evidence={"n_out": n, "n_dropped": report.get("n_dropped_total")},
+    )
+
+
+def check_entry_cids(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    if corpus is None or corpus.empty:
+        return Check(
+            id="entry_cid_unique",
+            severity="fail",
+            passed=False,
+            message="no entry_cid values to verify",
+            evidence={},
+        )
+    missing = int(corpus["entry_cid"].isna().sum()) if "entry_cid" in corpus.columns else int(len(corpus))
+    dupes = int(corpus["entry_cid"].duplicated().sum()) if "entry_cid" in corpus.columns else 0
+    empty = int((corpus["entry_cid"].astype(str).str.strip() == "").sum()) if "entry_cid" in corpus.columns else 0
+    ok = missing == 0 and dupes == 0 and empty == 0
+    return Check(
+        id="entry_cid_unique",
+        severity="fail",
+        passed=ok,
+        message="every row has a unique entry_cid" if ok else "missing or duplicate entry_cid",
+        evidence={"missing": missing, "empty": empty, "duplicate": dupes},
+    )
+
+
+def check_no_invented_text(report: dict[str, Any]) -> Check:
+    flag = bool(report.get("never_invented_legal_text", False))
+    return Check(
+        id="never_invented_legal_text",
+        severity="fail",
+        passed=flag,
+        message="normalizer did not invent legal text" if flag else "invented-text flag is false",
+        evidence={"never_invented_legal_text": flag},
+    )
+
+
+def check_html_residual(corpus: pd.DataFrame) -> Check:
+    bodies = _bodies(corpus)
+    tagged = [b for b in bodies if has_html_tags(b)]
+    n = len(bodies) or 1
+    fraction = len(tagged) / float(n)
+    passed = fraction <= _HTML_FAIL_FRACTION
+    return Check(
+        id="html_residual",
+        severity="fail",
+        passed=passed,
+        message=(
+            "HTML tags stripped from legal bodies"
+            if passed
+            else f"{len(tagged)}/{len(bodies)} bodies still contain HTML tags"
+        ),
+        evidence={
+            "n_bodies": len(bodies),
+            "n_with_tags": len(tagged),
+            "fraction": fraction,
+            "samples": [b[:120] for b in tagged[:5]],
+        },
+    )
+
+
+def check_short_bodies(corpus: pd.DataFrame) -> Check:
+    bodies = _bodies(corpus)
+    if not bodies:
+        return Check(
+            id="short_bodies",
+            severity="fail",
+            passed=False,
+            message="no bodies to measure",
+            evidence={},
+        )
+    short = sum(1 for b in bodies if len(b) < _MIN_BODY_CHARS)
+    fraction = short / float(len(bodies))
+    passed = fraction <= _SHORT_BODY_FAIL_FRACTION
+    return Check(
+        id="short_bodies",
+        severity="fail" if not passed else "warn",
+        passed=passed,
+        message=(
+            "most legal units have usable body length"
+            if passed
+            else f"{short}/{len(bodies)} bodies shorter than {_MIN_BODY_CHARS} characters"
+        ),
+        evidence={"n_short": short, "n_bodies": len(bodies), "fraction": fraction},
+    )
+
+
+def check_heading_language(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    """Warn when Latin heading dialect disagrees with the document language."""
+    from .profiles import NO_LATIN_SPLIT_LANGS, iso_lang
+
+    doc_lang = iso_lang(report.get("document_language_majority") or "")
+    head_lang = iso_lang(report.get("heading_language_majority") or "")
+    counts = report.get("heading_language_counts") or {}
+    if (
+        doc_lang in NO_LATIN_SPLIT_LANGS
+        and report.get("unit") == "structured"
+        and head_lang
+        and head_lang not in NO_LATIN_SPLIT_LANGS
+        and head_lang != doc_lang
+    ):
+        return Check(
+            id="heading_language",
+            severity="fail",
+            passed=False,
+            message=(
+                f"document language {doc_lang} was split with Latin headings ({head_lang}); "
+                "use script-specific article markers or collector article rows"
+            ),
+            evidence={"document_language": doc_lang, "heading_counts": counts, "unit": report.get("unit")},
+        )
+    if doc_lang and head_lang and doc_lang != head_lang and sum(counts.values()) >= 8:
+        return Check(
+            id="heading_language",
+            severity="warn",
+            passed=True,
+            message=(
+                f"heading lexicon majority is {head_lang} but documents are {doc_lang}; "
+                "review samples before trusting structure"
+            ),
+            evidence={
+                "document_language": doc_lang,
+                "heading_language": head_lang,
+                "heading_counts": counts,
+            },
+        )
+    return Check(
+        id="heading_language",
+        severity="warn",
+        passed=True,
+        message=(
+            f"heading lexicon {head_lang or 'none'} vs document language {doc_lang or 'unknown'}"
+        ),
+        evidence={
+            "document_language": doc_lang,
+            "heading_language": head_lang,
+            "heading_counts": counts,
+        },
+    )
+
+
+def check_parent_laws(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    """Fail if source had instruments but GraphRAG corpus has no law rows."""
+    n_in = int(report.get("n_laws_in") or 0)
+    n_law_rows = 0
+    if corpus is not None and not corpus.empty and "record_type" in corpus.columns:
+        n_law_rows = int((corpus["record_type"] == "law").sum())
+    n_law_rows = int(report.get("n_law_rows") or n_law_rows)
+    if n_in > 0 and n_law_rows == 0:
+        return Check(
+            id="parent_laws",
+            severity="fail",
+            passed=False,
+            message=(
+                f"source has {n_in} laws but corpus has 0 law rows "
+                "(articles were indexed without parent instruments)"
+            ),
+            evidence={"n_laws_in": n_in, "n_law_rows": n_law_rows},
+        )
+    return Check(
+        id="parent_laws",
+        severity="warn",
+        passed=True,
+        message=f"parent instruments present ({n_law_rows} law rows from {n_in} source laws)",
+        evidence={"n_laws_in": n_in, "n_law_rows": n_law_rows},
+    )
+
+
+def check_structure(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    unit = str(report.get("unit") or "")
+    n = int(len(corpus)) if corpus is not None else 0
+    structured_rows = 0
+    if corpus is not None and not corpus.empty:
+        if "hierarchy_path" in corpus.columns:
+            structured_rows = int((corpus["hierarchy_path"].fillna("").astype(str).str.len() > 0).sum())
+        if "record_type" in corpus.columns:
+            structured_rows = max(
+                structured_rows,
+                int(corpus["record_type"].isin(["article", "section"]).sum()),
+            )
+    coverage = structured_rows / float(n) if n else 0.0
+    # Article or structured units are success. Pure law-level is a warning, not a fail:
+    # many gazettes have no title/section markers.
+    if unit in {"article", "structured", "law+article", "law+structured"} or coverage >= 0.5:
+        return Check(
+            id="legal_structure",
+            severity="warn",
+            passed=True,
+            message=f"retrieval units are structured ({unit}, coverage={coverage:.2f})",
+            evidence={"unit": unit, "structured_rows": structured_rows, "coverage": coverage},
+        )
+    return Check(
+        id="legal_structure",
+        severity="warn",
+        passed=True,
+        message=(
+            "kept whole-instrument units; no title/article/section headings detected "
+            "(expected for some gazettes)"
+        ),
+        evidence={"unit": unit, "structured_rows": structured_rows, "coverage": coverage},
+    )
+
+
+def verify_normalized_corpus(
+    corpus: pd.DataFrame,
+    report: dict[str, Any],
+    *,
+    slug: str = "",
+) -> dict[str, Any]:
+    """Run all normalization verifiers. Fail-closed on any failed `fail` check."""
+    checks = [
+        check_nonempty(corpus, report),
+        check_entry_cids(corpus, report),
+        check_no_invented_text(report),
+        check_html_residual(corpus),
+        check_short_bodies(corpus),
+        check_parent_laws(corpus, report),
+        check_structure(corpus, report),
+        check_heading_language(corpus, report),
+    ]
+    failed = [c for c in checks if c.severity == "fail" and not c.passed]
+    admitted = not failed
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "slug": slug,
+        "admitted": admitted,
+        "n_checks": len(checks),
+        "n_failed": len(failed),
+        "failed_ids": [c.id for c in failed],
+        "checks": [c.to_dict() for c in checks],
+        "blocks_graphrag": not admitted,
+    }
+
+
+class NormalizationAdmissionError(RuntimeError):
+    """Raised when verifiers refuse to send a corpus to GraphRAG."""
+
+
+def verify_source(source: str) -> dict[str, Any]:
+    """Load a Hub/local pack, normalize, and run verifiers (no GraphRAG)."""
+    from .build import CACHE
+    from .catalog import get_country
+    from .normalize import build_corpus, load_source
+
+    country = get_country(source)
+    local = country.get("local_source_dir")
+    laws, articles, source_meta = load_source(local or country["repo"], CACHE)
+    corpus, report = build_corpus(laws, articles, source_meta)
+    verdict = verify_normalized_corpus(corpus, report, slug=country["slug"])
+    report["verification"] = verdict
+    return {
+        "slug": country["slug"],
+        "source": country["repo"],
+        "n_out": report.get("n_out"),
+        "unit": report.get("unit"),
+        "verification": verdict,
+        "drops": report.get("drops"),
+    }

data/bm25/documents/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d5b1b2c049eee968b5e6f9d8f6ad9e08ff5486d95979d38bbc85cfd4c3d8415a
-size 501263
+oid sha256:ffebeddf05da3e782aad210b042a5b1dec6092afb33fa7fdb5bfd957f1c52996
+size 513358

data/bm25/documents/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a3b9f3b04c80ca3c6b50747cc9c8a48237373e1a48b3467d8f4be2c07d9d5835
-size 484287
+oid sha256:1c0c76d50334c876b59d3e635a706e3bffb61dca83d633bd308527c44924980c
+size 504395

data/bm25/documents/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:29208abd1e55fa3d9128634f5b3abdb76eab6e04622d7f22d49a1161ec14388e
-size 463293
+oid sha256:ab034f772d3f23427c662b9463a226d54173fb83386740842c35a9f838a4927c
+size 489782

data/bm25/documents/part-000003.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b62303b83f19ddc1d55f321ce42f09caa27539cb7d4724cb245d89231e21e2be
-size 246417
+oid sha256:6911cd2bb6f7c2f3f7d35cb94cca63e5e68b4c88c3816b7c3873ebac459705a6
+size 457724

data/bm25/postings/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:494600cc82f1b3d6dbfaa05b1f7f867a90005f2b6b958ca00b767e3c62f1585d
-size 106349
+oid sha256:4270c6d7617221b9dd6a401f1733fa801092f282948ae04dcd513f256569e21d
+size 92819

data/bm25/postings/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:93628889d2fb65f24a9c48e47d622a498c8d145667187fbe75391c3266ec4fef
-size 105720
+oid sha256:70812cbac3868dd34ffc0dd255d2a7170933b41c6f734641448598c80b3be4f2
+size 162511

data/bm25/postings/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:686a1705a215dfdaedc9ea304ba69c436db3160bd65ef735a78a7558ef87a4e3
-size 121059
+oid sha256:8624d2f9b9abb3fbf22a9eb4115af00e30c8249c9f54c068742ba724d1ec14bc
+size 120821

data/bm25/postings/part-000003.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a932b74a5b07f429ed5aa4915ae27c56a0946c2e4e100427a23b02e4168894d9
-size 45415
+oid sha256:a6f922c703ba2deb068ea24bc7252421c2e0b436e2471efe6cd7dc41567363eb
+size 153968

data/bm25/postings/part-000004.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c58bcd1632128ea4cf483b95aa9be88bb1327550ffe4be405c76362779bf38a8
-size 112621
+oid sha256:e022b6209ffc4f514a85aa247e9d7e3dd7cfbdb4344b70b9b98475be3e1b1e34
+size 141594

data/bm25/postings/part-000005.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e006962a8e9fbeb3f518aba118ea33eb27a099ac8c6e9cbd249a6da2bdd58ce7
-size 133183
+oid sha256:7ceec0cd4542b8984385ec5e5fbc7154c18eaee344815afb11c78fa243aa8ee6
+size 142728

data/bm25/postings/part-000006.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b61c6477341715bbad747a60c872b3e2c32c7aa9a54fa800a9b8cdf0f280f2ab
-size 320649
+oid sha256:d76a151c18c7a2de870f9e893395dc44db631aa95571a8c499eadda5f9fd3ce4
+size 128555

data/bm25/postings/part-000007.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:381f3b2648d8e4f34d7b1b62e6517c1cc30cb283e1b48a4a01667287c442d779
-size 455025
+oid sha256:bd4c22df4f2312c06a32259da6a0c217d2604104b3045c42411fcaaa4800bdc3
+size 432728

data/bm25/postings/part-000008.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:95bbfdcb66521a0da27a8ec6869b3d9ac6e42d529ede55bde3fb17cd8173fb48
-size 597690
+oid sha256:d326b0a70c252ac257a5a426ecf9125305c5b28ba17527ffb919dd5999e7185e
+size 617863

data/bm25/postings/part-000009.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5c7106a0661c1253fd550634e28a7515220e42520b7ce4c1b9513ae3bdd993dc
-size 693372
+oid sha256:dc3b66602773add98b70ee3fe8e09e482bc8a4d1a9a0355b18d52f9a9212b20d
+size 834589

data/bm25/postings/part-000010.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:389e704a2013ce9bbc7ca2c846a5c934cc362edb90e97b16063583e5a3989da8
-size 408149
+oid sha256:7743a2dbaa0893c7d311482d87e42e5f64c98a9bf987b9e5450600a08dfc6121
+size 956886

data/bm25/postings/part-000011.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ab86bc6ddf48c8072a3cec33b6a3a2254c4c5bf79f20eae54134a97685ec38d2
-size 565290
+oid sha256:e47751997de26359e940299858ad19dbb7b0bb3e600f9795fff2291f61d52419
+size 561025

data/bm25/postings/part-000012.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1fb37a311decd8c61641b5fe6d5869705242dc206ac3505762f82ebb3e899db1
-size 622313
+oid sha256:a4efe955030668fee1ed26db1545ee1c1de919a61c8e1e72fe86620233d87610
+size 776840

data/bm25/postings/part-000013.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cdc9ceb0dab793d1776d907e2c6cfd07c3d4ad5834b11ad9ff5fc7f5f8d144f0
-size 590569
+oid sha256:b5937727b617f773f4ca837c96a3c2a061085f4e58d3455505b1d7a8a84f18fb
+size 851922

data/bm25/postings/part-000014.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3c311aefa3fc49b8c0e3b99e0ff38494f498b83d19e2c652492400083592bf11
-size 571075
+oid sha256:8d43a859923da0c18f1b356a7014ce3391817264c453212c8285c14226e5d07e
+size 888867

data/bm25/postings/part-000015.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a1f18da19ec633e11d78032996bbe2439e83ce1639b3c117af72d51473e44dca
-size 261877
+oid sha256:e7cb739836d62a19eb3326125e4d6695048fbb6c31e153851f506ae2787610d0
+size 763588

data/bm25/postings/part-000016.parquet

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

data/corpus/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:eb7d8c554113cbc0560f9e2d98d670c1d440b5553b6a0937df8f9c44888b39a4
-size 1951466
+oid sha256:ab974a2845f50a753e8cf522d670bc8fc350882a594e439a51fee1a882760c61
+size 2114859

data/corpus/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c5fa74a0b0f879dfda67f783f63817a96be691be3e68640d68b56af4ebc812dd
-size 1727243
+oid sha256:43beb750de02d16013a5063764a8b26a302cefa281a9c372e8144bcaa4cf9169
+size 2017293

data/corpus/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f6ecd95e6b87d219f99332a05226893f6dd2dca41f01e99f5bfbde2ef01acb54
-size 1751152
+oid sha256:a44db5e43e50f93b863bb836f868802d572a0da122027732a908a70d00c8bc2d
+size 1898388

data/corpus/part-000003.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f62cf8c89fef6c76f749a8d29f61f01f66527f3db5a82743bb61fdc601fd1fcf
-size 1079395
+oid sha256:79222f0246b060b5ed007d94e722636bf2460cec405b29854e9b24a4b5995ab4
+size 1966041

data/graph/adjacency/in/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8a86cbe58fa2eb58cd345c7ca8eaf6e219fbea34b61c1a378e76b4c49dde8a6c
-size 563014
+oid sha256:f0f4028fc01a25a8e6fe9d5431b56a298575f78127d7ac0536188025a987b687
+size 577124

data/graph/adjacency/in/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:554b9387ed59a575011de1b9eb3e35a15390f5708afd244897a50b9499ea1c10
-size 583151
+oid sha256:5b0f43d85d9fbb4708737589f4d3461843be50751a5a4a4e48f19292a5805636
+size 584309

data/graph/adjacency/in/part-000002.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6b60688fe5a41b61b0fdcd8c63ee1ac614375a39bbb5e3bfa71a26b6388990fa
-size 563252
+oid sha256:0799da0d7b773772d5f88a5385ff8f0c586dc8541100d974ed14bf474e47c00c
+size 579557

data/graph/adjacency/in/part-000003.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:62c7728bd631ca8037b287795b17fe98bd059750a4bc993f959e90c93c1f8e35
-size 410002
+oid sha256:40f0a161ef976d21ec007a2a56232a9f66e1def32c2df0d736dfa9f4abad75c0
+size 322534

data/graph/adjacency/in/part-000004.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e9877fb824e3748cb95ea6bea417900335b6377f786d0f93134dd6a09062c30b
-size 583330
+oid sha256:a1551f01d7574dd442effe3e1f1df8d71a6863f4410dee17faa934f78e1281d8
+size 584279

data/graph/adjacency/in/part-000005.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:85539b8d818514092fa67839ad8e6275589b888698a5fcf2360a68bf6c19857c
-size 563382
+oid sha256:09e76002403a7963fcb9c2fc034878b13e4393505f14ce99017842bafa4909e9
+size 580199

data/graph/adjacency/in/part-000006.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:3cf4c06829f023498f3ab3a3b1a6dcb06974b03c1e1d545ea980fe8169e02dca
-size 574601
+oid sha256:9e2daf8b3a33664c27899421285a78f0c7972ab4247c067f04836aee8af6df99
+size 593352

data/graph/adjacency/in/part-000007.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5a78e4bef1132fe838f24db475fbb7f9cad2564bdf3cd3fafd4bda854bbe1b05
-size 570762
+oid sha256:6b923a47549c142b50351b41e291cef2343128a7063ab840c6cf3e60b751a792
+size 595719

data/graph/adjacency/in/part-000008.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ace8971285550b720254363b05249b673675c9f897d6d5e7a497f30eace4792a
-size 398881
+oid sha256:e7587ee1b1ca7e1a3baad04f8e5a8b5e3e2046deb5a79b30efe3f2e53b98190b
+size 589095

data/graph/adjacency/in/part-000009.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:550483bb874d9b1b4a1a0dfef2279c2d46bb1e70d8ff73f545c47eb9fac890b3
-size 583119
+oid sha256:9f679a37b5dcab4ac024c75a1d531fa344b9c3c62c74b8c1f6d07ab0189c2a3d
+size 520675

data/graph/adjacency/in/part-000010.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d945f64abd04cd60a2ee1586ae33e25c42dc733b9c617e4b26ba03e6775dbb2d
-size 561848
+oid sha256:367dec54f2150f951b839181c7e6a6ca4687c98dc3577880bf0f4a2dba161fbe
+size 583911