Add files using upload-large-folder tool

README.md

@@ -0,0 +1,3 @@
+# justicedao/ipfs_kazakhstan_laws_ir
+
+Kazakhstan laws IR release.

country_laws_ir/__init__.py

@@ -0,0 +1,19 @@
+"""Country-law CID-keyed sparse GraphRAG packager (SkillCenter / publicus-ir family)."""
+
+__version__ = "0.3.0"
+# Layout matches SkillCenter HF release / publicus-ir family; schema string is domain-specific.
+SCHEMA_VERSION = "country-laws-ir-graphrag/v1"
+LAYOUT_FAMILY = "skillcenter-huggingface-release/v3"
+ENTRY_IDENTITY_SCHEMA = "country-laws-entry/v1"
+LAW_IDENTITY_SCHEMA = "country-laws-law/v1"
+FACET_IDENTITY_SCHEMA = "country-laws-facet/v1"
+EDGE_IDENTITY_SCHEMA = "country-laws-edge/v1"
+MAX_ROWS_PER_FILE = 4096
+TARGET_ORG = "justicedao"
+
+# CID payload: UTF-8 bytes of json.dumps(obj, sort_keys=True, ensure_ascii=False,
+# separators=(",", ":")) hashed as CIDv1 codec=raw (0x55) hash=sha2-256 (0x12)
+# multibase base32 (`bafkrei...`). Same payload -> same CID.
+CID_CODEC = "raw"
+CID_HASH = "sha2-256"
+CID_MULTIBASE = "base32"

country_laws_ir/__main__.py

@@ -0,0 +1,87 @@
+"""python -m country_laws_ir {build,query,batch,catalog}"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog="country_laws_ir")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p_build = sub.add_parser("build")
+    p_build.add_argument("--source-repo", "--source", dest="source", default="malta",
+                         help="Hub dataset id (endomorphosis/ipfs_<slug>_laws) or country slug")
+    p_build.add_argument("--out", default=None)
+    p_build.add_argument("--device", default="cpu")
+    p_build.add_argument("--neighbor-k", type=int, default=8)
+    p_build.add_argument("--skip-vectors", action="store_true")
+    p_build.add_argument("--upload", action="store_true")
+
+    p_batch = sub.add_parser("batch")
+    p_batch.add_argument("--slugs", nargs="*", default=None)
+    p_batch.add_argument("--upload", action="store_true")
+    p_batch.add_argument("--no-skip-done", action="store_true")
+
+    p_q = sub.add_parser("query")
+    p_q.add_argument("--local-dir", required=True)
+    p_q.add_argument("rest", nargs=argparse.REMAINDER)
+
+    p_norm = sub.add_parser("normalize")
+    p_norm.add_argument("--source-repo", "--source", dest="source", default="malta")
+    p_norm.add_argument("--out", default=None, help="Optional JSON report path")
+
+    sub.add_parser("catalog")
+
+    args = ap.parse_args(argv)
+    if args.cmd == "build":
+        from .build import build_country
+
+        result = build_country(
+            args.source,
+            out=Path(args.out) if args.out else None,
+            upload=args.upload,
+            device=args.device,
+            neighbor_k=args.neighbor_k,
+            skip_vectors=args.skip_vectors,
+        )
+        print(json.dumps({k: result[k] for k in result if k != "normalization"}, indent=2, default=str))
+        print(json.dumps({"normalization": result["normalization"]}, indent=2, default=str))
+        return 0
+    if args.cmd == "batch":
+        from .build import batch
+
+        results = batch(slugs=args.slugs, upload=args.upload, skip_done=not args.no_skip_done)
+        print(json.dumps([{"country": r["country"], "out": r["out"]} for r in results], indent=2))
+        return 0
+    if args.cmd == "query":
+        from .query import main as qmain
+
+        argv2 = ["--local-dir", args.local_dir] + [a for a in args.rest if a != "--"]
+        return qmain(argv2)
+    if args.cmd == "normalize":
+        from .build import CACHE, REPORTS, ROOT
+        from .catalog import get_country
+        from .normalize import build_corpus, load_source
+
+        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": report["n_out"], "unit": report["unit"], "drops": report["drops"]}, indent=2))
+        return 0
+    if args.cmd == "catalog":
+        from .catalog import COUNTRIES, indexable_countries
+
+        print(json.dumps({"n": len(COUNTRIES), "indexable": len(indexable_countries()), "countries": COUNTRIES}, indent=2))
+        return 0
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

country_laws_ir/auth.py

@@ -0,0 +1,16 @@
+"""Public Hugging Face reads only. This pipeline never loads, stores, or uses a token."""
+
+from __future__ import annotations
+
+import os
+
+
+def configure_hf() -> None:
+    """Force anonymous public Hub access. Tokens are ignored, never printed, never stored."""
+    os.environ["HF_HUB_DISABLE_IMPLICIT_TOKEN"] = "1"
+    # Do not read HF_TOKEN / HUGGING_FACE_HUB_TOKEN. Public datasets need no auth.
+
+
+def public_token() -> bool:
+    """huggingface_hub `token=False` means anonymous (do not pick up env tokens)."""
+    return False

country_laws_ir/bm25.py

@@ -0,0 +1,227 @@
+"""Okapi BM25 (k1=1.2, b=0.75, title_weight=5, body_weight=1) + posting shards."""
+
+from __future__ import annotations
+
+import math
+from collections import defaultdict
+from typing import Any, Iterable
+
+import numpy as np
+import pandas as pd
+
+from . import MAX_ROWS_PER_FILE, SCHEMA_VERSION
+from .tokenize import tokenize
+
+K1 = 1.2
+B = 0.75
+TITLE_WEIGHT = 5.0
+BODY_WEIGHT = 1.0
+POSTING_ROWS_PER_RECORD = 4096
+TERMS_PER_SHARD = 4096
+MAX_QUERY_TERMS = 64
+
+
+def _idf(n_docs: int, df: int) -> float:
+    # rank_bm25 Okapi: ln((N - df + 0.5) / (df + 0.5) + 1)
+    return math.log((n_docs - df + 0.5) / (df + 0.5) + 1.0)
+
+
+def build_index(corpus: pd.DataFrame) -> dict[str, Any]:
+    n = len(corpus)
+    titles = corpus["title"].fillna("").astype(str).tolist()
+    bodies = corpus["body"].fillna("").astype(str).tolist()
+    title_toks = [tokenize(t) for t in titles]
+    body_toks = [tokenize(t) for t in bodies]
+
+    title_len = np.array([len(t) for t in title_toks], dtype=np.int32)
+    body_len = np.array([len(t) for t in body_toks], dtype=np.int32)
+    doc_len = (title_len * TITLE_WEIGHT + body_len * BODY_WEIGHT).astype(np.float64)
+    avgdl = float(doc_len.mean()) if n else 0.0
+
+    # term -> {doc: [title_tf, body_tf]}
+    postings: dict[str, dict[int, list[int]]] = defaultdict(dict)
+    for i, (tt, bt) in enumerate(zip(title_toks, body_toks)):
+        tf_t: dict[str, int] = defaultdict(int)
+        tf_b: dict[str, int] = defaultdict(int)
+        for tok in tt:
+            tf_t[tok] += 1
+        for tok in bt:
+            tf_b[tok] += 1
+        for tok in set(tf_t) | set(tf_b):
+            postings[tok][i] = [int(tf_t.get(tok, 0)), int(tf_b.get(tok, 0))]
+
+    terms = sorted(postings)
+    idf = {t: _idf(n, len(postings[t])) for t in terms}
+
+    doc_rows = []
+    for i, row in corpus.iterrows():
+        idx = int(row["document_index"])
+        doc_rows.append(
+            {
+                "entry_cid": row["entry_cid"],
+                "document_index": idx,
+                "law_cid": row.get("law_cid", ""),
+                "instrument_id": row.get("instrument_id", row.get("law_id", "")),
+                "law_id": row.get("law_id", row.get("instrument_id", "")),
+                "source_id": row["source_id"],
+                "title": row["title"],
+                "instrument_title": row.get("instrument_title", ""),
+                "article_number": row.get("article_number", ""),
+                "article_title": row.get("article_title", ""),
+                "record_type": row["record_type"],
+                "language": row.get("language", ""),
+                "jurisdiction": row.get("jurisdiction", ""),
+                "title_length": int(title_len[idx]),
+                "body_length": int(body_len[idx]),
+                "document_length": int(round(doc_len[idx])),
+                "schema_version": SCHEMA_VERSION,
+            }
+        )
+    documents = pd.DataFrame(doc_rows).sort_values("document_index").reset_index(drop=True)
+
+    posting_rows = []
+    for term in terms:
+        items = sorted(postings[term].items())
+        chunks = [
+            items[i : i + POSTING_ROWS_PER_RECORD]
+            for i in range(0, max(len(items), 1), POSTING_ROWS_PER_RECORD)
+        ]
+        n_chunks = len(chunks)
+        dfreq = len(items)
+        cfreq = sum(v[0] + v[1] for _, v in items)
+        for cidx, chunk in enumerate(chunks):
+            posting_rows.append(
+                {
+                    "term": term,
+                    "document_indices": [d for d, _ in chunk],
+                    "title_frequencies": [v[0] for _, v in chunk],
+                    "body_frequencies": [v[1] for _, v in chunk],
+                    "tfs": [TITLE_WEIGHT * v[0] + BODY_WEIGHT * v[1] for _, v in chunk],
+                    "lengths": [int(round(doc_len[d])) for d, _ in chunk],
+                    "document_lengths": [int(round(doc_len[d])) for d, _ in chunk],
+                    "document_frequency": int(dfreq),
+                    "corpus_frequency": int(cfreq),
+                    "idf": float(idf[term]),
+                    "posting_chunk_index": int(cidx),
+                    "posting_chunk_count": int(n_chunks),
+                    "schema_version": SCHEMA_VERSION,
+                }
+            )
+    postings_df = pd.DataFrame(posting_rows)
+
+    stats = {
+        "k1": K1,
+        "b": B,
+        "title_weight": TITLE_WEIGHT,
+        "body_weight": BODY_WEIGHT,
+        "average_document_length": avgdl,
+        "tokenizer": "fts5-unicode61-remove-diacritics-2-python/v1",
+        "max_query_terms": MAX_QUERY_TERMS,
+        "posting_rows_per_record": POSTING_ROWS_PER_RECORD,
+        "terms_per_shard": TERMS_PER_SHARD,
+        "n_docs": n,
+        "n_terms": len(terms),
+        "n_posting_rows": int(len(postings_df)),
+        "n_postings": int(sum(len(postings[t]) for t in terms)),
+    }
+    return {
+        "documents": documents,
+        "postings": postings_df,
+        "postings_map": postings,
+        "idf": idf,
+        "doc_len": doc_len,
+        "avgdl": avgdl,
+        "title_toks": title_toks,
+        "body_toks": body_toks,
+        "stats": stats,
+    }
+
+
+def _tf_score(tf: float, dl: float, avgdl: float) -> float:
+    denom = tf + K1 * (1.0 - B + B * (dl / avgdl if avgdl else 0.0))
+    if denom == 0:
+        return 0.0
+    return (tf * (K1 + 1.0)) / denom
+
+
+def score_query(
+    query: str,
+    index: dict[str, Any],
+    top_k: int = 10,
+) -> list[tuple[int, float]]:
+    q_terms = tokenize(query)[:MAX_QUERY_TERMS]
+    if not q_terms:
+        return []
+    postings = index["postings_map"]
+    idf = index["idf"]
+    doc_len = index["doc_len"]
+    avgdl = index["avgdl"] or 1.0
+    scores: dict[int, float] = defaultdict(float)
+    for term in q_terms:
+        plist = postings.get(term)
+        if not plist:
+            continue
+        w = idf.get(term, 0.0)
+        for doc, (ttf, btf) in plist.items():
+            tf = TITLE_WEIGHT * ttf + BODY_WEIGHT * btf
+            scores[doc] += w * _tf_score(tf, float(doc_len[doc]), avgdl)
+    ranked = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)
+    return ranked[:top_k]
+
+
+def bm25_neighbors(index: dict[str, Any], k: int = 8) -> list[list[tuple[int, float, list[str]]]]:
+    """Top-k BM25 neighbors from title tokens (body prefix only if title is empty).
+
+    Each neighbor is (document_index, score, matched_terms).
+    """
+    import heapq
+
+    n = index["stats"]["n_docs"]
+    postings = index["postings_map"]
+    idf = index["idf"]
+    doc_len = index["doc_len"]
+    avgdl = index["avgdl"] or 1.0
+    title_toks = index["title_toks"]
+    body_toks = index["body_toks"]
+    df_cap = max(256, min(1500, n // 40 or 1))
+    term_docs: dict[str, np.ndarray] = {}
+    term_pay: dict[str, np.ndarray] = {}
+    for term, plist in postings.items():
+        if len(plist) > df_cap:
+            continue
+        docs = np.fromiter(plist.keys(), dtype=np.int32, count=len(plist))
+        tfs = np.empty(len(plist), dtype=np.float64)
+        for j, (doc, (ttf, btf)) in enumerate(plist.items()):
+            tf = TITLE_WEIGHT * ttf + BODY_WEIGHT * btf
+            tfs[j] = _tf_score(tf, float(doc_len[doc]), avgdl)
+        term_docs[term] = docs
+        term_pay[term] = tfs * float(idf.get(term, 0.0))
+
+    neighbors: list[list[tuple[int, float, list[str]]]] = [[] for _ in range(n)]
+    step = 20000 if n >= 40000 else max(n, 1)
+    for i in range(n):
+        if i and i % step == 0:
+            print(f"bm25 neighbors {i}/{n}", flush=True)
+        q_terms = title_toks[i][:16] or body_toks[i][:16]
+        if not q_terms:
+            continue
+        tf_q: dict[str, int] = defaultdict(int)
+        for tok in q_terms:
+            tf_q[tok] += 1
+        scores: dict[int, float] = defaultdict(float)
+        matched: dict[int, set[str]] = defaultdict(set)
+        for term, qtf in tf_q.items():
+            docs = term_docs.get(term)
+            if docs is None:
+                continue
+            pay = term_pay[term] * qtf
+            for doc, val in zip(docs, pay):
+                di = int(doc)
+                if di != i:
+                    scores[di] += float(val)
+                    matched[di].add(term)
+        if scores:
+            top = heapq.nlargest(k, scores.items(), key=lambda kv: kv[1])
+            neighbors[i] = [(doc, score, sorted(matched[doc])) for doc, score in top]
+    print(f"bm25 neighbors {n}/{n}", flush=True)
+    return neighbors

country_laws_ir/build.py

@@ -0,0 +1,237 @@
+"""End-to-end build: normalize → BM25 → graph → vectors → package (no upload by default)."""
+
+from __future__ import annotations
+
+import json
+
+import pandas as pd
+import traceback
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .bm25 import bm25_neighbors, build_index
+from .mem import MemAbort, checkpoint, log_mem
+from .spill import (
+    SQLITE_THRESHOLD,
+    build_bm25_tf_spill,
+    build_graph_from_neighbor_shards,
+    neighbors_via_sqlite,
+    should_use_sqlite,
+    spill_dir_for,
+    spill_pickle,
+)
+from .package import package_from_spill, package_release
+from .catalog import get_country, indexable_countries, target_repo
+from .graph import build_graph
+from .normalize import build_corpus, load_source
+from .auth import configure_hf
+from .vectors import encode_corpus, embeddings_available, layout_stub_vectors, layout_vectors
+
+ROOT = Path("/workspace/country-laws-ir")
+CACHE = ROOT / "cache"
+RELEASES = ROOT / "releases"
+REPORTS = ROOT / "reports"
+PROGRESS = ROOT / "progress.jsonl"
+
+
+def _log(msg: str) -> None:
+    ts = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    print(f"[{ts}] {msg}", flush=True)
+
+
+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")
+
+
+def build_country(
+    source: str,
+    out: Path | None = None,
+    upload: bool = False,
+    device: str = "cpu",
+    neighbor_k: int = 8,
+    skip_vectors: bool = False,
+) -> dict[str, Any]:
+    country = get_country(source)
+    if not country.get("indexable", True):
+        raise RuntimeError(f"{country['repo']} is excluded: {country.get('skip_reason')}")
+    repo = country["repo"]
+    out = Path(out) if out else RELEASES / f"ipfs_{country['slug']}_laws_ir"
+    local_dir = country.get("local_source_dir") or (
+        str(Path(source).resolve())
+        if Path(source).is_dir()
+        and (
+            (Path(source) / "data" / "laws.parquet").is_file()
+            or (Path(source) / "laws.parquet").is_file()
+        )
+        else None
+    )
+    _log(f"build start {repo} -> {out} (upload={upload}) local={local_dir}")
+    configure_hf()
+    CACHE.mkdir(parents=True, exist_ok=True)
+    REPORTS.mkdir(parents=True, exist_ok=True)
+    laws, articles, source_meta = load_source(local_dir or repo, CACHE)
+    _log(
+        f"source loaded laws={source_meta['n_laws_source']} "
+        f"articles={source_meta['n_articles_source']} rev={source_meta['source_revision']}"
+    )
+    corpus, norm_report = build_corpus(laws, articles, source_meta)
+    report_path = REPORTS / f"{country['slug']}_normalization.json"
+    report_path.write_text(json.dumps(norm_report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    (REPORTS / "normalization.json").write_text(
+        json.dumps(norm_report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    _log(
+        f"normalized docs={len(corpus)} unit={norm_report['unit']} "
+        f"dropped={norm_report['n_dropped_total']} report={report_path}"
+    )
+    if corpus.empty:
+        raise RuntimeError("Normalized corpus is empty; refusing to package")
+
+    import gc
+
+    n_docs = len(corpus)
+    spill = spill_dir_for(country["slug"], CACHE)
+    spill.mkdir(parents=True, exist_ok=True)
+    corpus_ckpt = CACHE / f"{country['slug']}_corpus.parquet"
+    corpus.to_parquet(corpus_ckpt, index=False)
+    checkpoint("after_normalize", log=_log)
+
+    vector_blocker = None
+    if skip_vectors:
+        vectors = layout_stub_vectors(corpus, reason="skip_vectors flag")
+        vector_blocker = "skip_vectors"
+        spill_pickle(spill / "vectors.pkl", vectors)
+        del vectors
+        gc.collect()
+    elif embeddings_available():
+        try:
+            ckpt = CACHE / "embeddings" / f"{country['slug']}.npy"
+            _log(f"vectors encode start n={n_docs} checkpoint={ckpt}")
+            embeddings = encode_corpus(corpus, device=device, checkpoint_path=str(ckpt))
+            vectors = layout_vectors(corpus, embeddings)
+            _log(f"vectors n={vectors['stats']['n_vectors']} shards={vectors['stats']['shard_count']}")
+            spill_pickle(spill / "vectors.pkl", vectors)
+            del embeddings, vectors
+            gc.collect()
+            checkpoint("vectors_spilled", log=_log)
+        except Exception as exc:
+            vector_blocker = f"embedding_failed: {exc}"
+            _log(f"vector embedding failed; writing stub ({exc})")
+            vectors = layout_stub_vectors(corpus, reason=vector_blocker)
+            spill_pickle(spill / "vectors.pkl", vectors)
+            del vectors
+            gc.collect()
+    else:
+        vector_blocker = "sentence-transformers/torch unavailable"
+        _log(f"vectors stub: {vector_blocker}")
+        vectors = layout_stub_vectors(corpus, reason=vector_blocker)
+        spill_pickle(spill / "vectors.pkl", vectors)
+        del vectors
+        gc.collect()
+
+    use_sqlite = should_use_sqlite(n_docs)
+    neighbor_via = "stock"
+    if use_sqlite:
+        _log(f"sqlite neighbors path n={n_docs} (>= {SQLITE_THRESHOLD}) spill={spill}")
+        # Free corpus body for neighbor stream — reload later for graph
+        del corpus
+        gc.collect()
+        neighbors_via_sqlite(corpus_ckpt, spill, n_docs, k=neighbor_k, log=_log)
+        neighbor_via = "sqlite_fts"
+        bm25_info = build_bm25_tf_spill(corpus_ckpt, spill, n_docs, log=_log)
+        corpus = pd.read_parquet(corpus_ckpt)
+        graph = build_graph_from_neighbor_shards(corpus, spill, log=_log)
+        spill_pickle(spill / "graph.pkl", graph)
+        del graph, corpus
+        gc.collect()
+        checkpoint("graph_spilled", log=_log)
+        code_root = Path(__file__).resolve().parent.parent
+        manifest = package_from_spill(
+            out, spill, corpus_ckpt, source_meta, country, code_root,
+            normalization_report=norm_report, expected_rows=n_docs,
+        )
+        _log(f"packaged sequential via={neighbor_via} {out}")
+    else:
+        bm25 = build_index(corpus)
+        _log(f"bm25 terms={bm25['stats']['n_terms']} postings={bm25['stats']['n_postings']}")
+        _log(f"bm25 neighbors start n={n_docs} k={neighbor_k}")
+        neighbors = bm25_neighbors(bm25, k=neighbor_k)
+        _log("bm25 neighbors done")
+        graph = build_graph(corpus, neighbors)
+        del neighbors
+        gc.collect()
+        _log(f"graph nodes={graph['stats']['n_nodes']} edges={graph['stats']['n_edges']}")
+        with open(spill / "vectors.pkl", "rb") as _vf:
+            import pickle as _pickle
+            vectors = _pickle.load(_vf)
+        code_root = Path(__file__).resolve().parent.parent
+        manifest = package_release(
+            out, corpus, bm25, graph, vectors, source_meta, country, code_root,
+            normalization_report=norm_report,
+        )
+        del corpus, bm25, graph, vectors
+        gc.collect()
+    _log(f"packaged {out}")
+    result = {
+        "country": country["slug"],
+        "source": repo,
+        "source_revision": source_meta["source_revision"],
+        "out": str(out),
+        "target_hub_id": target_repo(country["slug"]),
+        "counts": manifest["counts"],
+        "normalization": norm_report,
+        "vector_blocker": vector_blocker,
+        "neighbor_via": neighbor_via,
+        "schema_version": manifest["schema_version"],
+    }
+    if upload:
+        from .upload import upload_release
+
+        hub = upload_release(out, target_repo(country["slug"]))
+        result["hub"] = hub
+        _log(f"uploaded {hub['url']} rev={hub['revision']}")
+        record_progress({"event": "uploaded", **result})
+    else:
+        record_progress({"event": "built_local", **{k: v for k, v in result.items() if k != "normalization"}})
+    return result
+
+
+def batch(
+    slugs: list[str] | None = None,
+    upload: bool = False,
+    skip_done: bool = True,
+) -> list[dict[str, Any]]:
+    done = set()
+    if skip_done and PROGRESS.exists():
+        for line in PROGRESS.read_text(encoding="utf-8").splitlines():
+            if not line.strip():
+                continue
+            rec = json.loads(line)
+            if rec.get("event") in {"uploaded", "built_local"} and rec.get("country"):
+                done.add(rec["country"])
+    targets = slugs or [c["slug"] for c in indexable_countries()]
+    if "malta" in targets:
+        targets = ["malta"] + [s for s in targets if s != "malta"]
+    results = []
+    for slug in targets:
+        if skip_done and slug in done:
+            _log(f"skip already done {slug}")
+            continue
+        try:
+            results.append(build_country(slug, upload=upload))
+        except Exception as exc:
+            _log(f"FAILED {slug}: {exc}")
+            record_progress(
+                {
+                    "event": "failed",
+                    "country": slug,
+                    "error": str(exc),
+                    "traceback": traceback.format_exc(),
+                }
+            )
+            continue
+    return results

country_laws_ir/catalog.py

@@ -0,0 +1,183 @@
+"""Catalog of endomorphosis/ipfs_*_laws corpora.
+
+Belgium, Portugal, and Lithuania are incomplete Wayback harvests and are
+excluded from indexing. american_municipal_law is out of scope.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+EXCLUDED_SLUGS = {"belgium", "portugal", "lithuania"}
+EXCLUDED_REPOS = {f"endomorphosis/ipfs_{s}_laws" for s in EXCLUDED_SLUGS}
+
+# Hub listing as of 2026-09-03. Refresh via `python -m country_laws_ir catalog --refresh`.
+COUNTRIES: list[dict[str, Any]] = [
+    {"slug": "argentina", "repo": "endomorphosis/ipfs_argentina_laws", "name": "Argentina", "indexable": True},
+    {"slug": "australia", "repo": "endomorphosis/ipfs_australia_laws", "name": "Australia", "indexable": True},
+    {"slug": "austria", "repo": "endomorphosis/ipfs_austria_laws", "name": "Austria", "indexable": True},
+    {"slug": "bangladesh", "repo": "endomorphosis/ipfs_bangladesh_laws", "name": "Bangladesh", "indexable": True},
+    {"slug": "belgium", "repo": "endomorphosis/ipfs_belgium_laws", "name": "Belgium", "indexable": False,
+     "skip_reason": "incomplete Wayback harvest (Justel / Moniteur belge archive shard)"},
+    {"slug": "brazil", "repo": "endomorphosis/ipfs_brazil_laws", "name": "Brazil", "indexable": True},
+    {"slug": "canada", "repo": "endomorphosis/ipfs_canada_laws", "name": "Canada", "indexable": True},
+    {"slug": "chile", "repo": "endomorphosis/ipfs_chile_laws", "name": "Chile", "indexable": True},
+    {"slug": "china", "repo": "endomorphosis/ipfs_china_laws", "name": "China", "indexable": True},
+    {"slug": "colombia", "repo": "endomorphosis/ipfs_colombia_laws", "name": "Colombia", "indexable": True},
+    {"slug": "croatia", "repo": "endomorphosis/ipfs_croatia_laws", "name": "Croatia", "indexable": True},
+    {"slug": "czechia", "repo": "endomorphosis/ipfs_czechia_laws", "name": "Czechia", "indexable": True},
+    {"slug": "denmark", "repo": "endomorphosis/ipfs_denmark_laws", "name": "Denmark", "indexable": True},
+    {"slug": "egypt", "repo": "endomorphosis/ipfs_egypt_laws", "name": "Egypt", "indexable": True},
+    {"slug": "estonia", "repo": "endomorphosis/ipfs_estonia_laws", "name": "Estonia", "indexable": True},
+    {"slug": "eu", "repo": "endomorphosis/ipfs_eu_laws", "name": "European Union", "indexable": True},
+    {"slug": "finland", "repo": "endomorphosis/ipfs_finland_laws", "name": "Finland", "indexable": True},
+    {"slug": "france", "repo": "endomorphosis/ipfs_france_laws", "name": "France", "indexable": True},
+    {"slug": "ghana", "repo": "endomorphosis/ipfs_ghana_laws", "name": "Ghana", "indexable": False,
+     "skip_reason": "thin scrape; Act PDF path blocked by robots"},
+    {"slug": "germany", "repo": "endomorphosis/ipfs_germany_laws", "name": "Germany", "indexable": True},
+    {"slug": "greece", "repo": "endomorphosis/ipfs_greece_laws", "name": "Greece", "indexable": True},
+    {"slug": "hongkong", "repo": "endomorphosis/ipfs_hongkong_laws", "name": "Hong Kong", "indexable": True},
+    {"slug": "iceland", "repo": "endomorphosis/ipfs_iceland_laws", "name": "Iceland", "indexable": True},
+    {"slug": "hungary", "repo": "endomorphosis/ipfs_hungary_laws", "name": "Hungary", "indexable": True},
+    {"slug": "india", "repo": "endomorphosis/ipfs_india_laws", "name": "India", "indexable": True},
+    {"slug": "indonesia", "repo": "endomorphosis/ipfs_indonesia_laws", "name": "Indonesia", "indexable": True},
+    {"slug": "ireland", "repo": "endomorphosis/ipfs_ireland_laws", "name": "Ireland", "indexable": True},
+    {"slug": "israel", "repo": "endomorphosis/ipfs_israel_laws", "name": "Israel", "indexable": True},
+    {"slug": "japan", "repo": "endomorphosis/ipfs_japan_laws", "name": "Japan", "indexable": True},
+    {"slug": "kenya", "repo": "endomorphosis/ipfs_kenya_laws", "name": "Kenya", "indexable": True},
+    {"slug": "korea", "repo": "endomorphosis/ipfs_korea_laws", "name": "Korea (ROK)", "indexable": True},
+    {"slug": "kuwait", "repo": "endomorphosis/ipfs_kuwait_laws", "name": "Kuwait", "indexable": True},
+    {"slug": "latvia", "repo": "endomorphosis/ipfs_latvia_laws", "name": "Latvia", "indexable": True},
+    {"slug": "lithuania", "repo": "endomorphosis/ipfs_lithuania_laws", "name": "Lithuania", "indexable": False,
+     "skip_reason": "incomplete Wayback harvest (e-TAR archive shard)"},
+    {"slug": "luxembourg", "repo": "endomorphosis/ipfs_luxembourg_laws", "name": "Luxembourg", "indexable": True},
+    {"slug": "malaysia", "repo": "endomorphosis/ipfs_malaysia_laws", "name": "Malaysia", "indexable": True},
+    {"slug": "malta", "repo": "endomorphosis/ipfs_malta_laws", "name": "Malta", "indexable": True, "pilot": True},
+    {"slug": "morocco", "repo": "endomorphosis/ipfs_morocco_laws", "name": "Morocco", "indexable": True},
+    {"slug": "mexico", "repo": "endomorphosis/ipfs_mexico_laws", "name": "Mexico", "indexable": True},
+    {"slug": "netherlands", "repo": "endomorphosis/ipfs_netherlands_laws", "name": "Netherlands", "indexable": True},
+    {"slug": "newzealand", "repo": "endomorphosis/ipfs_newzealand_laws", "name": "New Zealand", "indexable": True},
+    {"slug": "nigeria", "repo": "endomorphosis/ipfs_nigeria_laws", "name": "Nigeria", "indexable": True},
+    {"slug": "norway", "repo": "endomorphosis/ipfs_norway_laws", "name": "Norway", "indexable": True},
+    {"slug": "pakistan", "repo": "endomorphosis/ipfs_pakistan_laws", "name": "Pakistan", "indexable": True},
+    {"slug": "philippines", "repo": "endomorphosis/ipfs_philippines_laws", "name": "Philippines", "indexable": True},
+    {"slug": "poland", "repo": "endomorphosis/ipfs_poland_laws", "name": "Poland", "indexable": True},
+    {"slug": "portugal", "repo": "endomorphosis/ipfs_portugal_laws", "name": "Portugal", "indexable": False,
+     "skip_reason": "incomplete Wayback harvest (Diário da República archive shard)"},
+    {"slug": "qatar", "repo": "endomorphosis/ipfs_qatar_laws", "name": "Qatar", "indexable": True},
+    {"slug": "russia", "repo": "endomorphosis/ipfs_russia_laws", "name": "Russia", "indexable": True},
+    {"slug": "saudiarabia", "repo": "endomorphosis/ipfs_saudiarabia_laws", "name": "Saudi Arabia", "indexable": True},
+    {"slug": "singapore", "repo": "endomorphosis/ipfs_singapore_laws", "name": "Singapore", "indexable": True},
+    {"slug": "slovakia", "repo": "endomorphosis/ipfs_slovakia_laws", "name": "Slovakia", "indexable": True},
+    {"slug": "southafrica", "repo": "endomorphosis/ipfs_southafrica_laws", "name": "South Africa", "indexable": True},
+    {"slug": "spain", "repo": "endomorphosis/ipfs_spain_laws", "name": "Spain", "indexable": True},
+    {"slug": "sweden", "repo": "endomorphosis/ipfs_sweden_laws", "name": "Sweden", "indexable": True},
+    {"slug": "switzerland", "repo": "endomorphosis/ipfs_switzerland_laws", "name": "Switzerland", "indexable": True},
+    {"slug": "taiwan", "repo": "endomorphosis/ipfs_taiwan_laws", "name": "Taiwan", "indexable": True},
+    {"slug": "thailand", "repo": "endomorphosis/ipfs_thailand_laws", "name": "Thailand", "indexable": True},
+    {"slug": "turkey", "repo": "endomorphosis/ipfs_turkey_laws", "name": "Turkey", "indexable": True},
+    {"slug": "uae", "repo": "endomorphosis/ipfs_uae_laws", "name": "United Arab Emirates", "indexable": True},
+    {"slug": "uk", "repo": "endomorphosis/ipfs_uk_laws", "name": "United Kingdom", "indexable": True},
+    {"slug": "ukraine", "repo": "endomorphosis/ipfs_ukraine_laws", "name": "Ukraine", "indexable": True},
+    {"slug": "vietnam", "repo": "endomorphosis/ipfs_vietnam_laws", "name": "Vietnam", "indexable": True},
+    {"slug": "bulgaria", "repo": "endomorphosis/ipfs_bulgaria_laws", "name": "Bulgaria", "indexable": True},
+    {"slug": "cyprus", "repo": "endomorphosis/ipfs_cyprus_laws", "name": "Cyprus", "indexable": True},
+    {"slug": "italy", "repo": "endomorphosis/ipfs_italy_laws", "name": "Italy", "indexable": True},
+    {"slug": "romania", "repo": "endomorphosis/ipfs_romania_laws", "name": "Romania", "indexable": True},
+    {"slug": "slovenia", "repo": "endomorphosis/ipfs_slovenia_laws", "name": "Slovenia", "indexable": True},
+]
+
+
+def get_country(source: str) -> dict[str, Any]:
+    source = source.strip()
+    # Local filtered pack: directory with data/laws.parquet (+ optional pack_meta.json)
+    from pathlib import Path as _Path
+    import json as _json
+
+    local = _Path(source)
+    if local.is_dir() and (
+        (local / "data" / "laws.parquet").is_file() or (local / "laws.parquet").is_file()
+    ):
+        pack_meta: dict[str, Any] = {}
+        meta_path = local / "pack_meta.json"
+        if meta_path.is_file():
+            try:
+                pack_meta = _json.loads(meta_path.read_text(encoding="utf-8"))
+            except Exception:
+                pack_meta = {}
+        slug = str(pack_meta.get("slug") or local.name)
+        # strip common cache prefixes like oman_filtered_c72f142a
+        if slug.startswith("oman"):
+            slug = "oman"
+        for prefix in ("ipfs_",):
+            if slug.startswith(prefix):
+                slug = slug[len(prefix):]
+        for suffix in ("_laws", "_filtered", "-ir"):
+            if slug.endswith(suffix):
+                slug = slug[: -len(suffix)]
+        # e.g. oman_filtered_c72f142a -> oman
+        if "_filtered" in slug:
+            slug = slug.split("_filtered", 1)[0]
+        repo = str(pack_meta.get("repo") or pack_meta.get("source_dataset") or f"endomorphosis/ipfs_{slug}_laws")
+        return {
+            "slug": slug,
+            "repo": repo,
+            "name": str(pack_meta.get("name") or slug.replace("_", " ").title()),
+            "indexable": bool(pack_meta.get("indexable", slug not in EXCLUDED_SLUGS)),
+            "skip_reason": pack_meta.get("skip_reason"),
+            "local_source_dir": str(local.resolve()),
+            "source_revision": pack_meta.get("source_revision"),
+        }
+
+    slug = source
+    if "/" in source:
+        slug = source.rsplit("/", 1)[-1]
+    slug = slug.removeprefix("ipfs_").removesuffix("_laws").removesuffix("-ir")
+    for row in COUNTRIES:
+        if row["slug"] == slug or row["repo"] == source or row["repo"].endswith("/" + source):
+            return dict(row)
+    if source.startswith("endomorphosis/ipfs_") and source.endswith("_laws"):
+        inferred = source.split("ipfs_", 1)[1].removesuffix("_laws")
+        return {
+            "slug": inferred,
+            "repo": source,
+            "name": inferred.replace("_", " ").title(),
+            "indexable": inferred not in EXCLUDED_SLUGS,
+            "skip_reason": "incomplete Wayback harvest" if inferred in EXCLUDED_SLUGS else None,
+        }
+    raise KeyError(f"Unknown country-law source: {source}")
+
+
+def indexable_countries() -> list[dict[str, Any]]:
+    return [c for c in COUNTRIES if c.get("indexable")]
+
+
+def target_repo(slug: str) -> str:
+    return f"justicedao/ipfs_{slug}_laws_ir"
+
+
+def refresh_from_hub() -> list[dict[str, Any]]:
+    """Anonymous Hub listing of public endomorphosis/ipfs_*_laws datasets."""
+    from huggingface_hub import HfApi
+
+    from .auth import configure_hf, public_token
+
+    configure_hf()
+    api = HfApi(token=public_token())
+    found: list[dict[str, Any]] = []
+    for ds in api.list_datasets(author="endomorphosis"):
+        ds_id = ds.id
+        if not ds_id.startswith("endomorphosis/ipfs_") or not ds_id.endswith("_laws"):
+            continue
+        slug = ds_id.split("ipfs_", 1)[1].removesuffix("_laws")
+        found.append({
+            "slug": slug,
+            "repo": ds_id,
+            "name": slug.replace("_", " ").title(),
+            "indexable": slug not in EXCLUDED_SLUGS,
+            "skip_reason": (
+                "incomplete Wayback harvest" if slug in EXCLUDED_SLUGS else None
+            ),
+        })
+    found.sort(key=lambda r: r["slug"])
+    return found

country_laws_ir/cidutil.py

@@ -0,0 +1,81 @@
+"""CIDv1 (raw + sha2-256) helpers. Produces bafkrei... identifiers.
+
+Payload format (deterministic):
+    json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+
+Codec: CIDv1 version=0x01, multicodec raw=0x55, multihash sha2-256=0x12, length=0x20,
+then 32-byte digest. Multibase prefix `b` + RFC 4648 base32 (lowercase, no padding).
+Same payload bytes always yield the same CID.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+
+_B32 = "abcdefghijklmnopqrstuvwxyz234567"
+
+
+def sha256_hex(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def sha256_file(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as f:
+        while True:
+            chunk = f.read(1024 * 1024)
+            if not chunk:
+                break
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def canonical_json_bytes(obj: Any) -> bytes:
+    return json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+
+
+def _b32encode(data: bytes) -> str:
+    bits = 0
+    value = 0
+    out = []
+    for byte in data:
+        value = (value << 8) | byte
+        bits += 8
+        while bits >= 5:
+            bits -= 5
+            out.append(_B32[(value >> bits) & 31])
+    if bits:
+        out.append(_B32[(value << (5 - bits)) & 31])
+    return "".join(out)
+
+
+def cid_v1_raw_sha256(data: bytes) -> str:
+    digest = hashlib.sha256(data).digest()
+    cid_bytes = bytes([0x01, 0x55, 0x12, 0x20]) + digest
+    return "b" + _b32encode(cid_bytes)
+
+
+def cid_of_json(obj: Any) -> str:
+    return cid_v1_raw_sha256(canonical_json_bytes(obj))
+
+
+def cid_of_text(*parts: str) -> str:
+    blob = "\n".join("" if p is None else str(p) for p in parts).encode("utf-8")
+    return cid_v1_raw_sha256(blob)
+
+
+def file_descriptor(path: Path, relative_path: str, extra: dict | None = None) -> dict:
+    data = path.read_bytes()
+    desc = {
+        "cid": cid_v1_raw_sha256(data),
+        "sha256": sha256_hex(data),
+        "size_bytes": len(data),
+        "relative_path": relative_path,
+    }
+    if extra:
+        desc.update(extra)
+    return desc

country_laws_ir/graph.py

@@ -0,0 +1,336 @@
+"""Property graph: entry nodes, facet nodes, BM25_NEIGHBOR_OF k=8, ARTICLE_OF, ELI."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any
+
+import pandas as pd
+
+from . import EDGE_IDENTITY_SCHEMA, FACET_IDENTITY_SCHEMA, SCHEMA_VERSION
+from .cidutil import cid_of_json
+
+# Facet kinds requested by the SkillCenter-style country-laws graph:
+# jurisdiction, language, instrument/law, source, status.
+FACET_FIELDS = (
+    ("jurisdiction", "HAS_JURISDICTION", "jurisdiction"),
+    ("language", "HAS_LANGUAGE", "language"),
+    ("instrument", "HAS_INSTRUMENT", "instrument_id"),
+    ("source", "HAS_SOURCE", "source_type"),
+    ("status", "HAS_STATUS", "law_status"),
+)
+ADJ_POINTERS_PER_ROW = 4096
+ADJ_POINTERS_PER_SHARD = 8192
+
+
+def _facet_cid(kind: str, value: str) -> str:
+    """CIDv1 raw sha2-256 of sorted JSON {kind, schema, value}."""
+    return cid_of_json(
+        {
+            "kind": kind,
+            "schema": FACET_IDENTITY_SCHEMA,
+            "value": value,
+        }
+    )
+
+
+def _edge_cid(source: str, edge_type: str, target: str) -> str:
+    return cid_of_json(
+        {
+            "edge_type": edge_type,
+            "schema": EDGE_IDENTITY_SCHEMA,
+            "source": source,
+            "target": target,
+        }
+    )
+
+
+def build_graph(
+    corpus: pd.DataFrame,
+    neighbors: list[list[tuple]],
+) -> dict[str, Any]:
+    nodes: list[dict[str, Any]] = []
+    edges: list[dict[str, Any]] = []
+    seen_facets: set[str] = set()
+    cid_by_idx = corpus["entry_cid"].tolist()
+
+    # Law identity nodes (targets of ARTICLE_OF when the parent is not a corpus entry).
+    law_nodes: dict[str, dict[str, Any]] = {}
+    entry_by_instrument: dict[str, str] = {}
+    for rec in corpus.itertuples(index=False):
+        law_cid = str(getattr(rec, "law_cid", "") or "")
+        instrument_id = str(getattr(rec, "instrument_id", "") or "")
+        if getattr(rec, "record_type", "") == "law" and instrument_id and rec.entry_cid:
+            entry_by_instrument.setdefault(instrument_id, rec.entry_cid)
+        if not law_cid or law_cid in law_nodes:
+            continue
+        law_nodes[law_cid] = {
+            "node_cid": law_cid,
+            "node_type": "law",
+            "entry_cid": "",
+            "label": getattr(rec, "instrument_title", None) or instrument_id,
+            "properties_json": _json(
+                {
+                    "instrument_id": instrument_id,
+                    "instrument_title": str(getattr(rec, "instrument_title", "") or ""),
+                    "jurisdiction": str(getattr(rec, "jurisdiction", "") or ""),
+                    "language": str(getattr(rec, "language", "") or ""),
+                    "law_cid": law_cid,
+                }
+            ),
+            "schema_version": SCHEMA_VERSION,
+        }
+
+    for law_node in law_nodes.values():
+        nodes.append(law_node)
+
+    for rec in corpus.itertuples(index=False):
+        node_type = "law_entry" if rec.record_type == "law" else "article"
+        title = getattr(rec, "title", None) or getattr(rec, "instrument_title", None) or rec.source_id
+        nodes.append(
+            {
+                "node_cid": rec.entry_cid,
+                "node_type": node_type,
+                "entry_cid": rec.entry_cid,
+                "label": title,
+                "properties_json": _props_tuple(rec),
+                "schema_version": SCHEMA_VERSION,
+            }
+        )
+        src = rec.entry_cid
+        row_map = rec._asdict() if hasattr(rec, "_asdict") else {}
+
+        for kind, edge_type, col in FACET_FIELDS:
+            value = str(row_map.get(col) or "").strip()
+            if not value:
+                continue
+            fc = _facet_cid(kind, value)
+            if fc not in seen_facets:
+                seen_facets.add(fc)
+                nodes.append(
+                    {
+                        "node_cid": fc,
+                        "node_type": f"facet_{kind}",
+                        "entry_cid": "",
+                        "label": f"{kind}:{value}",
+                        "properties_json": _json({"kind": kind, "value": value}),
+                        "schema_version": SCHEMA_VERSION,
+                    }
+                )
+            edges.append(_edge(src, edge_type, fc, "facet", 1.0, {"facet": kind, "value": value}))
+
+        # ELI / identifier links — only values present in the source, never invented.
+        eli = str(row_map.get("eli") or "").strip()
+        if eli:
+            fc = _facet_cid("eli", eli)
+            if fc not in seen_facets:
+                seen_facets.add(fc)
+                nodes.append(
+                    {
+                        "node_cid": fc,
+                        "node_type": "facet_eli",
+                        "entry_cid": "",
+                        "label": f"eli:{eli}",
+                        "properties_json": _json({"kind": "eli", "value": eli}),
+                        "schema_version": SCHEMA_VERSION,
+                    }
+                )
+            edges.append(_edge(src, "IDENTIFIED_BY_ELI", fc, "identifier", 1.0, {"eli": eli}))
+        ident = str(row_map.get("official_identifier") or row_map.get("identifier") or "").strip()
+        if ident and ident != eli:
+            fc = _facet_cid("identifier", ident)
+            if fc not in seen_facets:
+                seen_facets.add(fc)
+                nodes.append(
+                    {
+                        "node_cid": fc,
+                        "node_type": "facet_identifier",
+                        "entry_cid": "",
+                        "label": f"identifier:{ident}",
+                        "properties_json": _json({"kind": "identifier", "value": ident}),
+                        "schema_version": SCHEMA_VERSION,
+                    }
+                )
+            edges.append(
+                _edge(src, "IDENTIFIED_BY", fc, "identifier", 1.0, {"identifier": ident})
+            )
+
+        law_cid = str(row_map.get("law_cid") or "")
+        instrument_id = str(row_map.get("instrument_id") or "")
+        if rec.record_type == "article":
+            parent = entry_by_instrument.get(instrument_id) or law_cid
+            if parent and parent != rec.entry_cid:
+                edges.append(
+                    _edge(
+                        rec.entry_cid,
+                        "ARTICLE_OF",
+                        parent,
+                        "structural",
+                        1.0,
+                        {
+                            "instrument_id": instrument_id,
+                            "article_number": row_map.get("article_number"),
+                        },
+                    )
+                )
+        elif law_cid and rec.entry_cid != law_cid:
+            # Law-level corpus unit still points at its instrument identity node.
+            edges.append(
+                _edge(
+                    rec.entry_cid,
+                    "HAS_INSTRUMENT",
+                    law_cid,
+                    "structural",
+                    1.0,
+                    {"instrument_id": instrument_id},
+                )
+            )
+
+    for i, neigh in enumerate(neighbors):
+        src = cid_by_idx[i]
+        for item in neigh:
+            if len(item) == 3:
+                j, score, terms = item
+            else:
+                j, score = item[0], item[1]
+                terms = []
+            tgt = cid_by_idx[int(j)]
+            edges.append(
+                _edge(
+                    src,
+                    "BM25_NEIGHBOR_OF",
+                    tgt,
+                    "bm25-okapi",
+                    float(score),
+                    {"k": 8, "neighbor_index": int(j)},
+                    matched_terms=list(terms),
+                )
+            )
+
+    nodes_df = pd.DataFrame(nodes).drop_duplicates("node_cid").reset_index(drop=True)
+    nodes_df = nodes_df.sort_values(["node_type", "node_cid"]).reset_index(drop=True)
+    edges_df = pd.DataFrame(edges)
+    if not edges_df.empty:
+        edges_df = edges_df.drop_duplicates("edge_cid").reset_index(drop=True)
+        edges_df = edges_df.sort_values(["edge_type", "source_cid", "target_cid"]).reset_index(drop=True)
+
+    node_type = {r["node_cid"]: r["node_type"] for r in nodes_df.to_dict("records")}
+    incoming, outgoing = _adjacency(edges_df, node_type)
+    return {
+        "nodes": nodes_df,
+        "edges": edges_df,
+        "incoming": incoming,
+        "outgoing": outgoing,
+        "stats": {
+            "n_nodes": int(len(nodes_df)),
+            "n_edges": int(len(edges_df)),
+            "n_doc_nodes": int(nodes_df["node_type"].isin(["law_entry", "article", "law"]).sum()),
+            "n_facet_nodes": int(nodes_df["node_type"].astype(str).str.startswith("facet_").sum()),
+            "edge_types": sorted(edges_df["edge_type"].unique().tolist()) if not edges_df.empty else [],
+        },
+    }
+
+
+def _json(obj: dict) -> str:
+    import json
+
+    return json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(",", ":"))
+
+
+def _props_tuple(rec: Any) -> str:
+    keys = [
+        "record_type",
+        "instrument_id",
+        "instrument_title",
+        "law_cid",
+        "article_number",
+        "article_title",
+        "jurisdiction",
+        "language",
+        "source_url",
+        "snapshot_date",
+        "coverage",
+        "license",
+        "collector",
+        "source_id",
+        "eli",
+        "law_status",
+        "source_type",
+    ]
+    d = rec._asdict() if hasattr(rec, "_asdict") else {}
+    out = {}
+    for k in keys:
+        v = d.get(k, "")
+        if v is None or (isinstance(v, float) and pd.isna(v)):
+            v = ""
+        out[k] = str(v)
+    return _json(out)
+
+
+def _edge(
+    src: str,
+    etype: str,
+    tgt: str,
+    method: str,
+    score: float,
+    props: dict,
+    matched_terms: list[str] | None = None,
+) -> dict[str, Any]:
+    import json
+
+    terms = matched_terms or []
+    return {
+        "edge_cid": _edge_cid(src, etype, tgt),
+        "edge_type": etype,
+        "source_cid": src,
+        "target_cid": tgt,
+        "retrieval_method": method,
+        "score": float(score),
+        "query_terms_json": json.dumps(terms, ensure_ascii=False, separators=(",", ":")),
+        "matched_terms": terms,
+        "properties_json": _json({k: v for k, v in props.items() if v is not None}),
+        "schema_version": SCHEMA_VERSION,
+    }
+
+
+def _adjacency(edges: pd.DataFrame, node_type: dict[str, str]) -> tuple[pd.DataFrame, pd.DataFrame]:
+    out_map: dict[str, list[tuple[float, str, str, str]]] = defaultdict(list)
+    in_map: dict[str, list[tuple[float, str, str, str]]] = defaultdict(list)
+    if edges is None or edges.empty:
+        return pd.DataFrame(), pd.DataFrame()
+    for rec in edges.itertuples(index=False):
+        score = float(rec.score) if rec.score == rec.score else float("-inf")
+        out_map[rec.source_cid].append((score, rec.target_cid, rec.edge_type, rec.edge_cid))
+        in_map[rec.target_cid].append((score, rec.source_cid, rec.edge_type, rec.edge_cid))
+
+    def pages(mapping: dict[str, list], direction: str) -> pd.DataFrame:
+        rows = []
+        for node, items in mapping.items():
+            items = sorted(items, key=lambda t: (-t[0] if t[0] == t[0] else float("inf"), t[1]))
+            total = len(items)
+            page_size = ADJ_POINTERS_PER_ROW
+            n_pages = max(1, (total + page_size - 1) // page_size)
+            for p in range(n_pages):
+                chunk = items[p * page_size : (p + 1) * page_size]
+                rows.append(
+                    {
+                        "direction": direction,
+                        "node_cid": node,
+                        "page_index": p,
+                        "page_count": n_pages,
+                        "neighbor_count": len(chunk),
+                        "total_neighbor_count": total,
+                        "neighbor_cids": [t[1] for t in chunk],
+                        "neighbor_node_types": [node_type.get(t[1], "") for t in chunk],
+                        "edge_types": [t[2] for t in chunk],
+                        "edge_cids": [t[3] for t in chunk],
+                        "retrieval_methods": ["graph"] * len(chunk),
+                        "scores": [t[0] if t[0] != float("-inf") else None for t in chunk],
+                        "schema_version": SCHEMA_VERSION,
+                    }
+                )
+        if not rows:
+            return pd.DataFrame()
+        return pd.DataFrame(rows).sort_values(["node_cid", "page_index"]).reset_index(drop=True)
+
+    return pages(in_map, "incoming"), pages(out_map, "outgoing")

country_laws_ir/mem.py

@@ -0,0 +1,236 @@
+"""Process / host memory watchdog for large IR builds (DO OOM lesson).
+
+Env overrides:
+  IR_MEM_WARN_GIB   MemAvailable threshold to shed collectors (default 3.5)
+  IR_MEM_ABORT_GIB  MemAvailable abort floor (default 2.5)
+  IR_RSS_ABORT_GIB  process RSS hard abort (default 12.0)
+  IR_MEM_LOG_EVERY  rows between mem logs when callers pass every_n (default 5000)
+"""
+from __future__ import annotations
+
+import gc
+import os
+import signal
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Callable
+
+DEFAULT_WARN_GIB = 3.5
+DEFAULT_ABORT_AVAIL_GIB = 2.5
+DEFAULT_ABORT_RSS_GIB = 12.0
+DEFAULT_LOG_EVERY = 5000
+
+# Prefer shedding zero-article / lean collectors first; protect AT+DK until last.
+DEFAULT_SHED_ORDER: list[tuple[str, tuple[str, ...]]] = [
+    ("mm", ("collect_mm", "run_collector_cc.sh collect_mm")),
+    ("th", ("collect_th", "run_collector_cc.sh collect_th")),
+    ("is-reg", ("collect_is", "is-reg", "run_collector_cc.sh collect_is")),
+    ("lt", ("collect_lt", "run_collector_cc.sh collect_lt")),
+    ("kw", ("collect_kw", "run_collector_cc.sh collect_kw")),
+    ("mt", ("collect_mt", "run_collector_cc.sh collect_mt")),
+    ("dk", ("collect_dk", "run_collector_cc.sh collect_dk")),
+    ("at", ("collect_at", "run_collector_cc.sh collect_at", "at_deepen")),
+]
+
+
+class MemAbort(RuntimeError):
+    """Raised when MemAvailable or RSS crosses hard abort thresholds."""
+
+
+def _env_float(name: str, default: float) -> float:
+    raw = os.environ.get(name)
+    if raw is None or raw == "":
+        return default
+    try:
+        return float(raw)
+    except ValueError:
+        return default
+
+
+def warn_gib() -> float:
+    return _env_float("IR_MEM_WARN_GIB", DEFAULT_WARN_GIB)
+
+
+def abort_avail_gib() -> float:
+    return _env_float("IR_MEM_ABORT_GIB", DEFAULT_ABORT_AVAIL_GIB)
+
+
+def abort_rss_gib() -> float:
+    return _env_float("IR_RSS_ABORT_GIB", DEFAULT_ABORT_RSS_GIB)
+
+
+def log_every() -> int:
+    try:
+        return max(1, int(os.environ.get("IR_MEM_LOG_EVERY", DEFAULT_LOG_EVERY)))
+    except ValueError:
+        return DEFAULT_LOG_EVERY
+
+
+def mem_available_gib() -> float:
+    try:
+        for line in Path("/proc/meminfo").read_text().splitlines():
+            if line.startswith("MemAvailable:"):
+                return int(line.split()[1]) / 1024 / 1024
+    except Exception:
+        pass
+    return -1.0
+
+
+def rss_gib(pid: int | None = None) -> float:
+    path = Path(f"/proc/{pid or 'self'}/status")
+    try:
+        for line in path.read_text().splitlines():
+            if line.startswith("VmRSS:"):
+                return int(line.split()[1]) / 1024 / 1024
+    except Exception:
+        pass
+    return -1.0
+
+
+def snapshot(stage: str = "") -> dict[str, Any]:
+    return {
+        "stage": stage,
+        "mem_avail_gib": round(mem_available_gib(), 3),
+        "rss_gib": round(rss_gib(), 3),
+        "ts": datetime.now(timezone.utc).isoformat(),
+    }
+
+
+def log_mem(stage: str, log: Callable[[str], None] | None = None) -> dict[str, Any]:
+    snap = snapshot(stage)
+    msg = (
+        f"mem stage={stage} MemAvailable={snap['mem_avail_gib']:.2f}G "
+        f"RSS={snap['rss_gib']:.2f}G"
+    )
+    if log is not None:
+        log(msg)
+    else:
+        print(f"[{snap['ts']}] {msg}", flush=True)
+    return snap
+
+
+def discover_pids(*patterns: str) -> list[int]:
+    found: list[int] = []
+    try:
+        for proc in Path("/proc").iterdir():
+            if not proc.name.isdigit():
+                continue
+            try:
+                cmd = (proc / "cmdline").read_bytes().replace(b"\x00", b" ").decode(
+                    "utf-8", "ignore"
+                )
+            except Exception:
+                continue
+            if any(p in cmd for p in patterns):
+                found.append(int(proc.name))
+    except Exception:
+        pass
+    return found
+
+
+def shed_collectors(
+    stage: str,
+    *,
+    warn: float | None = None,
+    protect: frozenset[str] | None = None,
+    log: Callable[[str], None] | None = None,
+    notes: list[dict[str, Any]] | None = None,
+) -> list[dict[str, Any]]:
+    """SIGTERM lean collectors when MemAvailable < warn. Protect AT/DK by default until last."""
+    warn = warn_gib() if warn is None else warn
+    protect = protect if protect is not None else frozenset({"at", "dk"})
+    g = mem_available_gib()
+    out: list[dict[str, Any]] = []
+    if g < 0 or g >= warn:
+        return out
+    # First pass: non-protected; second pass: protected if still under warn.
+    for pass_protected in (False, True):
+        for name, pats in DEFAULT_SHED_ORDER:
+            if (name in protect) != pass_protected:
+                continue
+            pids = discover_pids(*pats)
+            for pid in pids:
+                try:
+                    os.kill(pid, 0)
+                except ProcessLookupError:
+                    continue
+                except PermissionError:
+                    continue
+                try:
+                    os.kill(pid, signal.SIGTERM)
+                    note = {
+                        "stage": stage,
+                        "name": name,
+                        "pid": pid,
+                        "mem_before": round(g, 2),
+                        "protected_pass": pass_protected,
+                    }
+                    out.append(note)
+                    if notes is not None:
+                        notes.append(note)
+                    msg = f"SIGTERM collector {name} pid={pid} mem={g:.2f}G stage={stage}"
+                    if log:
+                        log(msg)
+                    else:
+                        print(msg, flush=True)
+                except ProcessLookupError:
+                    pass
+                except Exception as exc:
+                    msg = f"SIGTERM failed {name} pid={pid}: {exc}"
+                    if log:
+                        log(msg)
+                    else:
+                        print(msg, flush=True)
+            g = mem_available_gib()
+            if g >= warn:
+                return out
+    return out
+
+
+def checkpoint(
+    stage: str,
+    *,
+    row: int | None = None,
+    every_n: int | None = None,
+    shed: bool = True,
+    abort: bool = True,
+    log: Callable[[str], None] | None = None,
+    notes: list[dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    """Periodic mem log + optional shed + hard abort.
+
+    Call every N rows with ``row`` set; always logs when row is None.
+    """
+    every = every_n if every_n is not None else log_every()
+    if row is not None and row != 0 and row % every != 0:
+        # Still enforce hard abort cheaply on every call.
+        rss = rss_gib()
+        avail = mem_available_gib()
+        if abort and rss >= abort_rss_gib():
+            raise MemAbort(f"RSS_ABORT stage={stage} rss={rss:.2f}G > {abort_rss_gib()}G")
+        if abort and 0 <= avail < abort_avail_gib():
+            if shed:
+                shed_collectors(stage, log=log, notes=notes)
+                avail = mem_available_gib()
+            if 0 <= avail < abort_avail_gib():
+                raise MemAbort(
+                    f"MEM_ABORT stage={stage} MemAvailable={avail:.2f}G < {abort_avail_gib()}G"
+                )
+        return snapshot(stage)
+
+    snap = log_mem(stage if row is None else f"{stage}@{row}", log=log)
+    if shed and 0 <= snap["mem_avail_gib"] < warn_gib():
+        shed_collectors(stage, log=log, notes=notes)
+        snap = log_mem(f"{stage}_after_shed", log=log)
+        gc.collect()
+    if abort:
+        if snap["rss_gib"] >= abort_rss_gib():
+            raise MemAbort(
+                f"RSS_ABORT stage={stage} rss={snap['rss_gib']:.2f}G > {abort_rss_gib()}G"
+            )
+        if 0 <= snap["mem_avail_gib"] < abort_avail_gib():
+            raise MemAbort(
+                f"MEM_ABORT stage={stage} MemAvailable={snap['mem_avail_gib']:.2f}G "
+                f"< {abort_avail_gib()}G"
+            )
+    return snap

country_laws_ir/normalize.py

@@ -0,0 +1,574 @@
+"""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.
+
+Public Hub reads only (token=False). No Hugging Face token is read or stored.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import unicodedata
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+from huggingface_hub import dataset_info, hf_hub_download
+
+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
+
+_WS_RE = re.compile(r"\s+", re.UNICODE)
+COLLECTOR_DEFAULT = "endomorphosis/ipfs_datasets_py"
+
+
+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
+
+
+def _s(value: Any) -> str:
+    return normalize_text(value)
+
+
+def _download(repo_id: str, filename: str, cache_dir: Path) -> Path:
+    configure_hf()
+    path = hf_hub_download(
+        repo_id=repo_id,
+        filename=filename,
+        repo_type="dataset",
+        token=public_token(),
+        cache_dir=str(cache_dir / "hf"),
+    )
+    return Path(path)
+
+
+def _resolve_local_parquet(root: Path, name: str) -> Path:
+    """Accept either <root>/data/<name>.parquet or <root>/<name>.parquet."""
+    for cand in (root / "data" / f"{name}.parquet", root / f"{name}.parquet"):
+        if cand.is_file():
+            return cand
+    raise FileNotFoundError(f"missing {name}.parquet under {root} (tried data/ and root)")
+
+
+def load_local_source(local_dir: Path) -> tuple[pd.DataFrame, pd.DataFrame, dict[str, Any]]:
+    """Load a local country-laws pack (filtered preprocess layout)."""
+    local_dir = Path(local_dir).resolve()
+    laws_path = _resolve_local_parquet(local_dir, "laws")
+    articles_path = _resolve_local_parquet(local_dir, "articles")
+    laws = pd.read_parquet(laws_path)
+    articles = pd.read_parquet(articles_path)
+    validate_laws(laws)
+    validate_articles(articles)
+    pack_meta: dict[str, Any] = {}
+    meta_path = local_dir / "pack_meta.json"
+    if meta_path.is_file():
+        try:
+            pack_meta = json.loads(meta_path.read_text(encoding="utf-8"))
+        except Exception:
+            pack_meta = {}
+    source_dataset = (
+        pack_meta.get("source_dataset")
+        or pack_meta.get("repo")
+        or f"local/{local_dir.name}"
+    )
+    source_revision = str(
+        pack_meta.get("source_revision")
+        or pack_meta.get("revision")
+        or f"local:{local_dir.name}"
+    )
+    meta = {
+        "source_dataset": source_dataset,
+        "source_revision": source_revision,
+        "laws_path": str(laws_path),
+        "articles_path": str(articles_path),
+        "laws_sha256": sha256_file(laws_path),
+        "articles_sha256": sha256_file(articles_path),
+        "n_laws_source": int(len(laws)),
+        "n_articles_source": int(len(articles)),
+        "laws_columns": list(map(str, laws.columns)),
+        "articles_columns": list(map(str, articles.columns)),
+        "article_count_dtype": str(laws["article_count"].dtype) if "article_count" in laws.columns else None,
+        "schema_surprises": _schema_surprises(laws, articles),
+        "local_source_dir": str(local_dir),
+        "pack_meta": pack_meta,
+    }
+    return laws, articles, meta
+
+
+def load_source(repo_id: str, cache_dir: Path) -> tuple[pd.DataFrame, pd.DataFrame, dict[str, Any]]:
+    """Load Hub dataset id OR a local directory with laws/articles parquet."""
+    local = Path(repo_id)
+    if local.is_dir() and (
+        (local / "data" / "laws.parquet").is_file() or (local / "laws.parquet").is_file()
+    ):
+        return load_local_source(local)
+
+    configure_hf()
+    os.environ.setdefault("HF_HOME", str(cache_dir / "hf"))
+    info = dataset_info(repo_id, token=public_token())
+    revision = info.sha
+    laws_path = _download(repo_id, "data/laws.parquet", cache_dir)
+    articles_path = _download(repo_id, "data/articles.parquet", cache_dir)
+    laws = pd.read_parquet(laws_path)
+    articles = pd.read_parquet(articles_path)
+    validate_laws(laws)
+    validate_articles(articles)
+    meta = {
+        "source_dataset": repo_id,
+        "source_revision": revision,
+        "laws_path": str(laws_path),
+        "articles_path": str(articles_path),
+        "laws_sha256": sha256_file(laws_path),
+        "articles_sha256": sha256_file(articles_path),
+        "n_laws_source": int(len(laws)),
+        "n_articles_source": int(len(articles)),
+        "laws_columns": list(map(str, laws.columns)),
+        "articles_columns": list(map(str, articles.columns)),
+        "article_count_dtype": str(laws["article_count"].dtype) if "article_count" in laws.columns else None,
+        "schema_surprises": _schema_surprises(laws, articles),
+    }
+    return laws, articles, meta
+
+
+def _schema_surprises(laws: pd.DataFrame, articles: pd.DataFrame) -> list[str]:
+    notes: list[str] = []
+    if articles is None or articles.empty:
+        notes.append("articles.parquet has 0 rows; corpus falls back to law-level units")
+    if "article_count" in laws.columns:
+        dtype = str(laws["article_count"].dtype)
+        notes.append(f"laws.article_count dtype={dtype}")
+        try:
+            if int((laws["article_count"].fillna(0) == 0).sum()) == len(laws):
+                notes.append("every law has article_count=0")
+        except Exception:
+            pass
+    for col in ("date", "date_issued"):
+        if col in laws.columns and laws[col].isna().all():
+            notes.append(f"laws.{col} is entirely null")
+    if "eli" in laws.columns:
+        n_eli = int(laws["eli"].notna().sum()) if hasattr(laws["eli"], "notna") else 0
+        notes.append(f"laws.eli non-null={n_eli}/{len(laws)}")
+    if "language" in laws.columns:
+        langs = sorted({str(x) for x in laws["language"].dropna().unique()})
+        notes.append(f"laws.language values={langs}")
+    return notes
+
+
+def _parse_meta(raw: str) -> dict[str, Any]:
+    if not raw:
+        return {}
+    try:
+        obj = json.loads(raw)
+        return obj if isinstance(obj, dict) else {}
+    except Exception:
+        return {}
+
+
+def _law_cid(instrument_id: str, instrument_title: str, jurisdiction: str, language: str, source_dataset: str) -> str:
+    identity = {
+        "schema": LAW_IDENTITY_SCHEMA,
+        "source_dataset": source_dataset,
+        "instrument_id": instrument_id,
+        "instrument_title": instrument_title,
+        "jurisdiction": jurisdiction,
+        "language": language,
+    }
+    return cid_of_json(identity)
+
+
+def _entry_cid(record: dict[str, Any]) -> str:
+    identity = {
+        "schema": ENTRY_IDENTITY_SCHEMA,
+        "record_type": record["record_type"],
+        "source_dataset": record["source_dataset"],
+        "instrument_id": record["instrument_id"],
+        "article_number": record.get("article_number") or "",
+        "article_title": record.get("article_title") or "",
+        "body_sha256": record["body_sha256"],
+        "language": record.get("language") or "",
+        "jurisdiction": record.get("jurisdiction") or "",
+        "source_url": record.get("source_url") or "",
+    }
+    return cid_of_json(identity)
+
+
+def _row_get(row: pd.Series, col: str, default: str = "") -> str:
+    if col not in row.index:
+        return default
+    return _s(row[col])
+
+
+def _coverage_from(
+    row: pd.Series,
+    meta: dict[str, Any],
+    articles_empty: bool,
+    sparse_fallback: bool = False,
+) -> str:
+    for key in ("coverage", "coverage_note"):
+        if key in meta and meta[key]:
+            return normalize_text(meta[key])
+    status = normalize_text(meta.get("article_extraction_status") or "")
+    if sparse_fallback:
+        note = "law-level (article coverage below 10% of laws; sparse articles table)"
+        if status:
+            return f"{note}; extraction_status={status}"
+        return note
+    if articles_empty:
+        if status:
+            return f"law-level (articles empty or unavailable in source snapshot); extraction_status={status}"
+        return "law-level (articles empty or unavailable in source snapshot)"
+    if status:
+        return f"article-level; extraction_status={status}"
+    return "article-level"
+
+
+def _snapshot_date(row: pd.Series, meta: dict[str, Any], source_meta: dict[str, Any]) -> str:
+    for col in ("retrieved_at", "date_issued", "date"):
+        val = _row_get(row, col)
+        if val:
+            return val[:10] if len(val) >= 10 and val[4] == "-" else val
+    for key in ("snapshot_date", "retrieved_at"):
+        if key in meta and meta[key]:
+            return normalize_text(str(meta[key]))[:10]
+    nested = meta.get("metadata") if isinstance(meta.get("metadata"), dict) else {}
+    for key in ("snapshot_date", "retrieved_at"):
+        if nested.get(key):
+            return normalize_text(str(nested[key]))[:10]
+    return ""
+
+
+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):
+        for key in ("collector", "collector_id", "harvester"):
+            if blob.get(key):
+                return normalize_text(blob[key])
+    return f"{COLLECTOR_DEFAULT} ({source_dataset})"
+
+
+def laws_index(laws: pd.DataFrame, source_dataset: str) -> dict[str, dict[str, Any]]:
+    """Map instrument_id -> law facet fields (always computed; not always corpus units)."""
+    out: dict[str, dict[str, Any]] = {}
+    for _, row in laws.iterrows():
+        instrument_id = _row_get(row, "id")
+        instrument_title = _row_get(row, "title")
+        jurisdiction = _row_get(row, "jurisdiction") or _row_get(row, "country")
+        language = _row_get(row, "language")
+        law_cid = _law_cid(instrument_id, instrument_title, jurisdiction, language, source_dataset)
+        meta = _parse_meta(_row_get(row, "metadata_json"))
+        out[instrument_id] = {
+            "instrument_id": instrument_id,
+            "instrument_title": instrument_title,
+            "law_cid": law_cid,
+            "jurisdiction": jurisdiction,
+            "language": language,
+            "source_url": _row_get(row, "source_url"),
+            "license": _row_get(row, "license"),
+            "eli": _row_get(row, "eli"),
+            "identifier": _row_get(row, "identifier") or instrument_id,
+            "official_identifier": _row_get(row, "official_identifier"),
+            "source_type": _row_get(row, "source_type"),
+            "country": _row_get(row, "country"),
+            "law_status": _row_get(row, "law_status"),
+            "body": _row_get(row, "text"),
+            "metadata": meta,
+            "row": row,
+        }
+    return out
+
+
+def _base_record(
+    *,
+    record_type: str,
+    source_dataset: str,
+    source_revision: str,
+    instrument_id: str,
+    instrument_title: str,
+    law_cid: str,
+    article_number: str,
+    article_title: str,
+    body: str,
+    jurisdiction: str,
+    language: str,
+    source_url: str,
+    snapshot_date: str,
+    coverage: str,
+    license_expr: str,
+    collector: str,
+    source_id: str,
+    extra: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    title_for_bm25 = article_title if record_type == "article" and article_title else instrument_title
+    rec: dict[str, Any] = {
+        "record_type": record_type,
+        "source_dataset": source_dataset,
+        "source_revision": source_revision,
+        "source_id": source_id,
+        "instrument_id": instrument_id,
+        "instrument_title": instrument_title,
+        "law_id": instrument_id,
+        "law_cid": law_cid,
+        "article_number": article_number,
+        "article_title": article_title,
+        "title": title_for_bm25,
+        "body": body,
+        "body_sha256": sha256_hex(body.encode("utf-8")),
+        "jurisdiction": jurisdiction,
+        "language": language,
+        "source_url": source_url,
+        "snapshot_date": snapshot_date,
+        "coverage": coverage,
+        "license": license_expr,
+        "collector": collector,
+        "schema_version": SCHEMA_VERSION,
+        "entry_identity_schema_version": ENTRY_IDENTITY_SCHEMA,
+    }
+    if extra:
+        rec.update(extra)
+    rec["entry_cid"] = _entry_cid(rec)
+    rec["title_length"] = len(title_for_bm25)
+    rec["body_length"] = len(body)
+    rec["document_length"] = len(title_for_bm25) + len(body)
+    return rec
+
+
+def build_corpus(
+    laws: pd.DataFrame,
+    articles: pd.DataFrame,
+    source_meta: dict[str, Any],
+) -> tuple[pd.DataFrame, dict[str, Any]]:
+    source_dataset = source_meta["source_dataset"]
+    source_revision = source_meta["source_revision"]
+    law_map = laws_index(laws, source_dataset)
+    articles_empty = articles is None or articles.empty
+    n_laws = int(len(laws))
+    n_arts = int(len(articles) if articles is not None else 0)
+    article_law_coverage = (n_arts / n_laws) if n_laws else 0.0
+    # Empty articles.parquet already falls back. Also fall back when the table is
+    # present but covers under ~10% as many rows as laws (Estonia: 2 vs 3484).
+    sparse_fallback = (not articles_empty) and article_law_coverage < 0.10
+    use_articles = (not articles_empty) and not sparse_fallback
+
+    extraction_statuses: Counter[str] = Counter()
+    for parent in law_map.values():
+        st = normalize_text(parent["metadata"].get("article_extraction_status") or "")
+        if st:
+            extraction_statuses[st] += 1
+
+    report: dict[str, Any] = {
+        "source_dataset": source_dataset,
+        "source_revision": source_revision,
+        "laws_sha256": source_meta.get("laws_sha256"),
+        "articles_sha256": source_meta.get("articles_sha256"),
+        "n_laws_in": int(len(laws)),
+        "n_articles_in": int(len(articles) if articles is not None else 0),
+        "unit": "article" if use_articles else "law",
+        "article_law_coverage": article_law_coverage,
+        "sparse_article_fallback": sparse_fallback,
+        "drops": {
+            "empty_body": 0,
+            "missing_instrument": 0,
+            "duplicate_cid": 0,
+            "duplicate_source_kept_first": 0,
+        },
+        "drop_samples": {
+            "empty_body": [],
+            "missing_instrument": [],
+            "duplicate_cid": [],
+        },
+        "language_breakdown": {},
+        "quality_flags": {},
+        "schema_surprises": list(source_meta.get("schema_surprises") or []),
+        "n_out": 0,
+        "never_invented_legal_text": True,
+    }
+
+    entries: list[dict[str, Any]] = []
+
+    if sparse_fallback:
+        report["schema_surprises"].append(
+            f"article coverage {article_law_coverage:.4f} < 0.10 of laws; falling back to law-level units"
+        )
+
+    if use_articles:
+        for _, row in articles.iterrows():
+            source_id = _row_get(row, "id")
+            instrument_id = _row_get(row, "law_id")
+            body = _row_get(row, "text")
+            article_title = _row_get(row, "title")
+            article_number = _row_get(row, "article_number")
+            if not body:
+                report["drops"]["empty_body"] += 1
+                if len(report["drop_samples"]["empty_body"]) < 20:
+                    report["drop_samples"]["empty_body"].append(source_id)
+                continue
+            parent = law_map.get(instrument_id)
+            if not parent:
+                report["drops"]["missing_instrument"] += 1
+                if len(report["drop_samples"]["missing_instrument"]) < 20:
+                    report["drop_samples"]["missing_instrument"].append(
+                        {"article_id": source_id, "law_id": instrument_id}
+                    )
+                continue
+            meta = parent["metadata"]
+            art_meta = _parse_meta(_row_get(row, "metadata_json"))
+            merged_meta = {**meta, **art_meta}
+            entries.append(
+                _base_record(
+                    record_type="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=article_number,
+                    article_title=article_title,
+                    body=body,
+                    jurisdiction=parent["jurisdiction"],
+                    language=parent["language"] or _row_get(row, "language"),
+                    source_url=_row_get(row, "source_url") or parent["source_url"],
+                    snapshot_date=_snapshot_date(parent["row"], merged_meta, source_meta),
+                    coverage=_coverage_from(parent["row"], merged_meta, articles_empty=False),
+                    license_expr=parent["license"],
+                    collector=_collector(merged_meta, source_dataset),
+                    source_id=source_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": instrument_id,
+                        "article_id": source_id,
+                    },
+                )
+            )
+    else:
+        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": "",
+                    },
+                )
+            )
+
+    entries.sort(
+        key=lambda r: (
+            r["instrument_id"],
+            r.get("article_number") or "",
+            r["source_id"],
+        )
+    )
+    n_before = len(entries)
+    seen: set[str] = set()
+    deduped: list[dict[str, Any]] = []
+    for rec in entries:
+        cid = rec["entry_cid"]
+        if cid in seen:
+            report["drops"]["duplicate_cid"] += 1
+            report["drops"]["duplicate_source_kept_first"] += 1
+            if len(report["drop_samples"]["duplicate_cid"]) < 20:
+                report["drop_samples"]["duplicate_cid"].append(rec["source_id"])
+            continue
+        seen.add(cid)
+        deduped.append(rec)
+    for i, rec in enumerate(deduped):
+        rec["document_index"] = i
+        rec["corpus_index"] = i
+
+    df = pd.DataFrame(deduped)
+    if not df.empty and df["entry_cid"].duplicated().any():
+        raise SchemaError("Duplicate entry_cid remained after dedupe")
+    report["n_before_dedupe"] = n_before
+    report["n_out"] = int(len(df))
+    report["n_dropped_total"] = (
+        report["drops"]["empty_body"]
+        + report["drops"]["missing_instrument"]
+        + report["drops"]["duplicate_cid"]
+    )
+    if not df.empty:
+        report["language_breakdown"] = {
+            str(k): int(v) for k, v in df["language"].fillna("").value_counts().items()
+        }
+        report["record_type_breakdown"] = {
+            str(k): int(v) for k, v in df["record_type"].value_counts().items()
+        }
+        report["jurisdiction_breakdown"] = {
+            str(k): int(v) for k, v in df["jurisdiction"].fillna("").value_counts().items()
+        }
+        snapshot_dates = sorted({str(x) for x in df["snapshot_date"].fillna("") if str(x)})
+        report["snapshot_dates"] = snapshot_dates
+    else:
+        report["language_breakdown"] = {}
+        report["record_type_breakdown"] = {}
+        report["jurisdiction_breakdown"] = {}
+        report["snapshot_dates"] = []
+
+    all_article_count_zero = False
+    if "article_count" in laws.columns and len(laws):
+        try:
+            all_article_count_zero = int((laws["article_count"].fillna(0) == 0).sum()) == len(laws)
+        except Exception:
+            all_article_count_zero = False
+
+    report["quality_flags"] = {
+        "articles_table_empty": bool(articles_empty),
+        "sparse_article_fallback": bool(sparse_fallback),
+        "article_law_coverage": article_law_coverage,
+        "all_source_article_counts_zero": all_article_count_zero,
+        "article_extraction_status_counts": dict(extraction_statuses),
+        "missing_date": bool("date" in laws.columns and laws["date"].isna().all()) if len(laws) else False,
+        "missing_date_issued": bool("date_issued" in laws.columns and laws["date_issued"].isna().all()) if len(laws) else False,
+        "eli_present": bool("eli" in laws.columns and laws["eli"].notna().any()) if len(laws) else False,
+        "never_invented_legal_text": True,
+        "empty_bodies_dropped": report["drops"]["empty_body"],
+        "duplicate_cids_dropped": report["drops"]["duplicate_cid"],
+    }
+    df.attrs["normalization_report"] = report
+    return df, report

country_laws_ir/package.py

@@ -0,0 +1,877 @@
+"""Write country-laws-ir-graphrag/v1 thin-client layout (SkillCenter / publicus-ir family)."""
+
+from __future__ import annotations
+
+import gc
+import json
+import pickle
+import shutil
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+from . import LAYOUT_FAMILY, MAX_ROWS_PER_FILE, SCHEMA_VERSION, __version__
+from .catalog import target_repo
+from .cidutil import file_descriptor
+from .parquet_io import write_parquet, write_sharded
+
+ADJ_POINTERS_PER_ROW = 4096
+ADJ_POINTERS_PER_SHARD = 8192
+
+
+def _index_df(rows: list[dict[str, Any]]) -> pd.DataFrame:
+    return pd.DataFrame(rows)
+
+
+def package_release(
+    out: Path,
+    corpus: pd.DataFrame,
+    bm25: dict[str, Any],
+    graph: dict[str, Any],
+    vectors: dict[str, Any],
+    source_meta: dict[str, Any],
+    country: dict[str, Any],
+    code_root: Path,
+    normalization_report: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    if out.exists():
+        shutil.rmtree(out)
+    out.mkdir(parents=True, exist_ok=True)
+    indexes_dir = out / "indexes"
+    indexes_dir.mkdir(parents=True, exist_ok=True)
+
+    corpus_idx = write_sharded(
+        corpus,
+        out / "data" / "corpus",
+        "data/corpus",
+        kind="corpus",
+        key_col="entry_cid",
+        index_col="document_index",
+    )
+    write_parquet(indexes_dir / "corpus_chunks.parquet", _index_df(corpus_idx))
+
+    bm25_doc_idx = write_sharded(
+        bm25["documents"],
+        out / "data" / "bm25" / "documents",
+        "data/bm25/documents",
+        kind="bm25_documents",
+        key_col="entry_cid",
+        index_col="document_index",
+    )
+    write_parquet(indexes_dir / "bm25_document_chunks.parquet", _index_df(bm25_doc_idx))
+
+    postings = bm25["postings"]
+    posting_idx = write_sharded(
+        postings,
+        out / "data" / "bm25" / "postings",
+        "data/bm25/postings",
+        kind="bm25_postings",
+        key_col="term",
+    )
+    for row, part_start in zip(posting_idx, range(len(posting_idx))):
+        shard_df = postings.iloc[part_start * MAX_ROWS_PER_FILE : (part_start + 1) * MAX_ROWS_PER_FILE]
+        row["term_count"] = int(shard_df["term"].nunique()) if not shard_df.empty else 0
+        row["posting_count"] = int(shard_df["document_indices"].map(len).sum()) if not shard_df.empty else 0
+        row["token_instance_count"] = row["posting_count"]
+    write_parquet(indexes_dir / "bm25_keyword_shards.parquet", _index_df(posting_idx))
+
+    node_idx = write_sharded(
+        graph["nodes"],
+        out / "data" / "graph" / "nodes",
+        "data/graph/nodes",
+        kind="graph_nodes",
+        key_col="node_cid",
+    )
+    write_parquet(indexes_dir / "graph_node_chunks.parquet", _index_df(node_idx))
+
+    edge_idx = write_sharded(
+        graph["edges"],
+        out / "data" / "graph" / "edges",
+        "data/graph/edges",
+        kind="graph_edges",
+        key_col="edge_cid",
+    )
+    write_parquet(indexes_dir / "graph_edge_chunks.parquet", _index_df(edge_idx))
+
+    incoming = graph["incoming"]
+    outgoing = graph["outgoing"]
+    in_idx = write_sharded(
+        incoming if incoming is not None and not incoming.empty else pd.DataFrame(
+            columns=["node_cid", "page_index", "direction"]
+        ),
+        out / "data" / "graph" / "adjacency" / "incoming",
+        "data/graph/adjacency/incoming",
+        kind="graph_incoming_adjacency",
+        key_col="node_cid",
+    )
+    out_idx = write_sharded(
+        outgoing if outgoing is not None and not outgoing.empty else pd.DataFrame(
+            columns=["node_cid", "page_index", "direction"]
+        ),
+        out / "data" / "graph" / "adjacency" / "outgoing",
+        "data/graph/adjacency/outgoing",
+        kind="graph_outgoing_adjacency",
+        key_col="node_cid",
+    )
+    for rows, direction in ((in_idx, "incoming"), (out_idx, "outgoing")):
+        for r in rows:
+            r["direction"] = direction
+            r["adjacency_count"] = r.get("row_count", 0)
+            r["node_count"] = r.get("row_count", 0)
+            r["first_page_index"] = 0
+            r["last_page_index"] = 0
+    write_parquet(indexes_dir / "graph_incoming_adjacency.parquet", _index_df(in_idx))
+    write_parquet(indexes_dir / "graph_outgoing_adjacency.parquet", _index_df(out_idx))
+
+    vectors_df = vectors["vectors"]
+    # Drop null embeddings for stub releases so parquet stays typed; keep rows when present.
+    if "embedding" in vectors_df.columns and vectors_df["embedding"].isna().all():
+        vectors_write = vectors_df.drop(columns=["embedding"])
+        vectors_write["embedding_status"] = "stub_missing"
+    else:
+        vectors_write = vectors_df
+    vec_idx = write_sharded(
+        vectors_write,
+        out / "data" / "vectors",
+        "data/vectors",
+        kind="vectors",
+        key_col="entry_cid",
+        index_col="document_index",
+    )
+    meta_by_cluster = {m["cluster_id"]: m for m in vectors["chunk_meta"]}
+    for r in vec_idx:
+        m = meta_by_cluster.get(r["shard_id"], {})
+        r["centroid"] = m.get("centroid", [])
+        r["shard_centroid"] = m.get("shard_centroid", [])
+        r["centroid_min_score"] = m.get("centroid_min_score", 0.0)
+        r["centroid_shard_count"] = m.get("centroid_shard_count", 1)
+        r["chunk_in_cluster"] = m.get("chunk_in_cluster", 0)
+        r["cluster_id"] = m.get("cluster_id", r["shard_id"])
+        r["dimension"] = 384
+        r["model_name"] = "thenlper/gte-small"
+        if m.get("stub"):
+            r["stub"] = True
+            r["stub_reason"] = m.get("stub_reason", "")
+    write_parquet(indexes_dir / "vector_chunks.parquet", _index_df(vec_idx))
+
+    # Bundle package + scripts into the release
+    pkg_src = Path(__file__).resolve().parent
+    dest_pkg = out / "country_laws_ir"
+    shutil.copytree(
+        pkg_src,
+        dest_pkg,
+        dirs_exist_ok=True,
+        ignore=shutil.ignore_patterns("__pycache__", "*.pyc", ".venv"),
+    )
+    scripts_dir = out / "scripts"
+    scripts_dir.mkdir(exist_ok=True)
+    for name in (
+        "build_country_laws_ir.py",
+        "normalize_country_laws.py",
+        "query_country_laws_hf.py",
+        "query_country_laws_ir.py",
+        "generate_country_laws_ir.py",
+    ):
+        src = code_root / "scripts" / name
+        if src.exists():
+            shutil.copy2(src, scripts_dir / name)
+    shutil.copy2(pkg_src / "normalize.py", out / "normalize.py")
+    shutil.copy2(pkg_src / "query.py", out / "query.py")
+    shutil.copy2(pkg_src / "build.py", out / "build.py")
+    _write_skill(out, country, hub_id=target_repo(country["slug"]))
+
+    reports_dir = out / "reports"
+    reports_dir.mkdir(exist_ok=True)
+    if normalization_report is not None:
+        payload = json.dumps(normalization_report, indent=2, ensure_ascii=False) + "\n"
+        (out / "normalization_report.json").write_text(payload, encoding="utf-8")
+        (reports_dir / "normalization.json").write_text(payload, encoding="utf-8")
+
+    n_laws = int((corpus["record_type"] == "law").sum()) if "record_type" in corpus else 0
+    n_articles = int((corpus["record_type"] == "article").sum()) if "record_type" in corpus else 0
+    counts = {
+        "bm25_document_chunks": len(bm25_doc_idx),
+        "bm25_documents": int(len(bm25["documents"])),
+        "bm25_keyword_shards": len(posting_idx),
+        "bm25_posting_rows": int(len(postings)),
+        "bm25_postings": int(bm25["stats"]["n_postings"]),
+        "bm25_terms": int(bm25["stats"]["n_terms"]),
+        "corpus_chunks": len(corpus_idx),
+        "corpus_rows": int(len(corpus)),
+        "graph_edge_chunks": len(edge_idx),
+        "graph_edges": int(len(graph["edges"])),
+        "graph_incoming_adjacency_edges": int(len(graph["edges"])),
+        "graph_incoming_adjacency_rows": int(len(incoming)) if incoming is not None else 0,
+        "graph_incoming_adjacency_shards": len(in_idx),
+        "graph_node_chunks": len(node_idx),
+        "graph_nodes": int(len(graph["nodes"])),
+        "graph_outgoing_adjacency_edges": int(len(graph["edges"])),
+        "graph_outgoing_adjacency_rows": int(len(outgoing)) if outgoing is not None else 0,
+        "graph_outgoing_adjacency_shards": len(out_idx),
+        "vector_chunks": len(vec_idx),
+        "vector_rows": int(len(vectors_df)),
+        "n_laws": n_laws,
+        "n_articles": n_articles,
+    }
+
+    def idx_desc(name: str) -> dict[str, Any]:
+        path = indexes_dir / name
+        return file_descriptor(path, f"indexes/{name}")
+
+    hub_id = target_repo(country["slug"])
+    edge_types = graph["stats"].get("edge_types") or [
+        "HAS_JURISDICTION",
+        "HAS_LANGUAGE",
+        "BELONGS_TO_LAW",
+        "HAS_ARTICLE",
+        "BM25_NEIGHBOR_OF",
+    ]
+    manifest = {
+        "schema_version": SCHEMA_VERSION,
+        "layout_family": LAYOUT_FAMILY,
+        "packager_version": __version__,
+        "primary_key": "entry_cid",
+        "dataset_id": source_meta["source_dataset"],
+        "dataset_repo_id": hub_id,
+        "dataset_revision": source_meta["source_revision"],
+        "country": country,
+        "disclaimer": "Research snapshot. Not legal advice. The official gazette / authentic source prevails.",
+        "bm25": {k: bm25["stats"][k] for k in (
+            "k1", "b", "title_weight", "body_weight", "average_document_length",
+            "tokenizer", "max_query_terms", "posting_rows_per_record", "terms_per_shard",
+        )},
+        "counts": counts,
+        "parquet": {
+            "compression": "zstd",
+            "compression_level": 6,
+            "max_rows_per_file": MAX_ROWS_PER_FILE,
+            "row_group_size": MAX_ROWS_PER_FILE,
+        },
+        "graph": {
+            "adjacency_pointers_per_row": ADJ_POINTERS_PER_ROW,
+            "adjacency_pointers_per_shard": ADJ_POINTERS_PER_SHARD,
+            "directions": ["incoming", "outgoing"],
+            "max_remote_walk_depth": 8,
+            "ordering": "score_desc_nulls_last",
+            "edge_types": edge_types,
+        },
+        "vector": vectors["stats"],
+        "canonical_fields": [
+            "entry_cid",
+            "law_cid",
+            "record_type",
+            "jurisdiction",
+            "language",
+            "instrument_id",
+            "instrument_title",
+            "article_number",
+            "article_title",
+            "title",
+            "body",
+            "source_url",
+            "snapshot_date",
+            "coverage",
+            "license",
+            "collector",
+            "source_dataset",
+            "source_revision",
+        ],
+        "input_sha256": {
+            "laws.parquet": source_meta.get("laws_sha256"),
+            "articles.parquet": source_meta.get("articles_sha256"),
+        },
+        "model_id": (vectors.get("stats") or {}).get("model_name", "thenlper/gte-small"),
+        "cid": {
+            "codec": "raw",
+            "hash": "sha2-256",
+            "multibase": "base32",
+            "payload": "json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(',', ':')).encode('utf-8')",
+        },
+        "normalization": normalization_report or {},
+        "schema_mapping": {
+            "laws": {
+                "id": "instrument_id",
+                "title": "instrument_title",
+                "text": "body",
+                "article_count_dtype_source": source_meta.get("article_count_dtype"),
+            },
+            "articles": {
+                "id": "source_id / article identity",
+                "law_id": "instrument_id",
+                "title": "article_title",
+                "text": "body",
+            },
+            "unit_policy": "prefer articles; fall back to law-level when articles empty",
+            "required_law_columns": ["id", "title", "text"],
+            "required_article_columns": ["id", "law_id", "title", "text"],
+            "fail_closed": True,
+            "notes": (
+                "Malta and Germany share the same column names. Drift: Malta article_count "
+                "is int64, Germany article_count is int32; Germany eli is often null. "
+                "Identifiers are never invented. Layout matches SkillCenter HF release / publicus-ir family."
+            ),
+        },
+        "indexes": {
+            "bm25_document_chunks": idx_desc("bm25_document_chunks.parquet"),
+            "bm25_keyword_shards": idx_desc("bm25_keyword_shards.parquet"),
+            "corpus_chunks": idx_desc("corpus_chunks.parquet"),
+            "graph_edge_chunks": idx_desc("graph_edge_chunks.parquet"),
+            "graph_incoming_adjacency": idx_desc("graph_incoming_adjacency.parquet"),
+            "graph_node_chunks": idx_desc("graph_node_chunks.parquet"),
+            "graph_outgoing_adjacency": idx_desc("graph_outgoing_adjacency.parquet"),
+            "vector_chunks": idx_desc("vector_chunks.parquet"),
+        },
+        "source": source_meta,
+    }
+    (out / "manifest.json").write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    _write_readme(out, country, source_meta, counts, bm25["stats"], graph["stats"], vectors["stats"], hub_id)
+    _write_gitattributes(out)
+    return manifest
+
+
+def _write_gitattributes(out: Path) -> None:
+    (out / ".gitattributes").write_text(
+        "*.parquet filter=lfs diff=lfs merge=lfs -text\n"
+        "*.bin filter=lfs diff=lfs merge=lfs -text\n",
+        encoding="utf-8",
+    )
+
+
+def _write_readme(
+    out: Path,
+    country: dict[str, Any],
+    source_meta: dict[str, Any],
+    counts: dict[str, Any],
+    bm25_stats: dict[str, Any],
+    graph_stats: dict[str, Any],
+    vector_stats: dict[str, Any],
+    hub_id: str,
+) -> None:
+    slug = country["slug"]
+    name = country["name"]
+    src = source_meta["source_dataset"]
+    rev = source_meta["source_revision"]
+    vec_status = vector_stats.get("status", "embedded")
+    text = f"""---
+license: other
+task_categories:
+- text-retrieval
+tags:
+- legal
+- law
+- graphrag
+- bm25
+- research
+- not-legal-advice
+- {slug}
+pretty_name: {name} laws IR (CID-keyed GraphRAG)
+configs:
+- config_name: corpus
+  data_files:
+  - split: train
+    path: data/corpus/*.parquet
+- config_name: bm25_documents
+  data_files:
+  - split: train
+    path: data/bm25/documents/*.parquet
+- config_name: bm25_postings
+  data_files:
+  - split: train
+    path: data/bm25/postings/*.parquet
+- config_name: bm25_keyword_index
+  data_files:
+  - split: train
+    path: indexes/bm25_keyword_shards.parquet
+- config_name: vectors
+  data_files:
+  - split: train
+    path: data/vectors/*.parquet
+- config_name: vector_meta_index
+  data_files:
+  - split: train
+    path: indexes/vector_chunks.parquet
+- config_name: graph_nodes
+  data_files:
+  - split: train
+    path: data/graph/nodes/*.parquet
+- config_name: graph_edges
+  data_files:
+  - split: train
+    path: data/graph/edges/*.parquet
+- config_name: graph_outgoing_adjacency
+  data_files:
+  - split: train
+    path: data/graph/adjacency/outgoing/*.parquet
+- config_name: graph_incoming_adjacency
+  data_files:
+  - split: train
+    path: data/graph/adjacency/incoming/*.parquet
+---
+
+# {name} legislation IR (CID-keyed sparse GraphRAG)
+
+Research retrieval release of `{src}` (revision `{rev}`) packaged as
+`{SCHEMA_VERSION}` (layout family `{LAYOUT_FAMILY}` / publicus-ir).
+
+**Not legal advice.** This is a research snapshot. The official gazette /
+authentic source of {name} prevails over this corpus. Retrieved documents
+and graph edges are retrieval evidence only. No legal text was invented.
+
+Primary key: `entry_cid` (CIDv1 raw sha2-256 of a canonical identity record).
+Integer `document_index` values are compact shard pointers, not identities.
+
+Target Hub id (packaging metadata only): `{hub_id}`.
+
+## Counts
+
+| Field | Value |
+| --- | --- |
+| Laws (corpus units) | {counts['n_laws']} |
+| Articles (corpus units) | {counts['n_articles']} |
+| Canonical docs | {counts['corpus_rows']} |
+| BM25 terms | {counts['bm25_terms']} |
+| BM25 postings | {counts['bm25_postings']} |
+| Graph nodes | {counts['graph_nodes']} |
+| Graph edges | {counts['graph_edges']} |
+| Vectors | {counts['vector_rows']} × {vector_stats['dimension']}-d `{vector_stats['model_name']}` ({vec_status}) |
+
+## Canonical fields
+
+`entry_cid`, `law_cid`, `record_type`, `jurisdiction`, `language`,
+`instrument_id`, `instrument_title`, `article_number`, `article_title`,
+`title`, `body`, `source_url`, `snapshot_date`, `coverage`, `license`,
+`collector`, `source_dataset`, `source_revision`.
+
+Unit policy: prefer article/section rows; fall back to law-level when
+`articles.parquet` is empty.
+
+## Index layout
+
+Zstandard parquet shards with at most 4,096 rows.
+
+- `indexes/bm25_keyword_shards.parquet` — lexical term ranges → BM25 posting shards
+- `indexes/vector_chunks.parquet` — semantic routing centroids (rows sorted by cosine to shard centroid)
+- `indexes/corpus_chunks.parquet` — document ranges → corpus shards
+- `data/graph/nodes` / `data/graph/edges` — property graph
+- `data/graph/adjacency/{{incoming,outgoing}}` — score-ordered neighbor pages
+
+BM25: Okapi k1=1.2, b=0.75, title_weight=5, body_weight=1 (FTS5 unicode61-style tokenizer).
+
+Graph: one node per `entry_cid` plus facet nodes (`_facet_cid(kind, value)` for
+jurisdiction, language, instrument, source, status). Neighbor edges
+`BM25_NEIGHBOR_OF` (k=8) carry score and matched terms. Structural edges:
+`ARTICLE_OF` (article → parent law) when articles exist, plus `IDENTIFIED_BY_ELI`
+/ `IDENTIFIED_BY` only when those identifiers are present in the source.
+
+## Query
+
+```
+python scripts/query_country_laws_hf.py --local-dir . bm25 "constitution" --top-k 10
+python scripts/query_country_laws_hf.py --local-dir . vector "money laundering" --top-k 10
+python scripts/query_country_laws_hf.py --local-dir . graph neighbors <entry_cid>
+```
+
+## Publish later (operator)
+
+```
+export HF_TOKEN=...   # never commit
+hf upload-large-folder {hub_id} . \\
+  --repo-type dataset --no-private --num-workers 8 \\
+  --exclude "**/__pycache__/**" --exclude "**/*.pyc"
+```
+
+## Provenance
+
+Packaged by country-laws-ir. Upstream collector and official license remain those
+of `{src}`. CIDs identify local content; they do not prove public IPFS pinning.
+"""
+    (out / "README.md").write_text(text, encoding="utf-8")
+
+
+def _write_skill(out: Path, country: dict[str, Any], hub_id: str) -> None:
+    skill_dir = out / "skill" / "query-country-laws-hf"
+    skill_dir.mkdir(parents=True, exist_ok=True)
+    name = country.get("name") or country.get("slug")
+    slug = country.get("slug")
+    text = f"""---
+name: query-country-laws-hf
+description: Query a local or Hub country-laws-ir GraphRAG release (BM25, vectors, graph neighbors). Research retrieval only — not legal advice.
+---
+
+# Query country-laws-ir (SkillCenter-style sparse GraphRAG)
+
+Thin client for `{hub_id}` / local release roots that follow
+`country-laws-ir-graphrag/v1` (layout family `skillcenter-huggingface-release/v3`).
+
+**Not legal advice.** Official gazettes prevail. Retrieved hits are context only.
+
+## Local
+
+```bash
+python scripts/query_country_laws_hf.py --local-dir . bm25 "constitution" --top-k 5
+python scripts/query_country_laws_hf.py --local-dir . vector "money laundering" --top-k 5
+python scripts/query_country_laws_hf.py --local-dir . graph neighbors <entry_cid>
+```
+
+Or:
+
+```bash
+python -m country_laws_ir query --local-dir /workspace/country-laws-ir/releases/ipfs_{slug}_laws_ir -- bm25 "constitution"
+```
+
+## Method
+
+- Primary key `entry_cid` (CIDv1 raw sha2-256). `document_index` is a shard pointer.
+- BM25 Okapi k1=1.2 b=0.75, title_weight=5, body_weight=1, FTS5-style tokenizer.
+- Vectors `thenlper/gte-small` 384-d, mean-pool, L2, centroid-sorted shards.
+- Graph: facets + `BM25_NEIGHBOR_OF` (k=8, score + matched terms) + `ARTICLE_OF`.
+
+Do not treat retrieval as proof. Do not invent citations.
+"""
+    (skill_dir / "SKILL.md").write_text(text, encoding="utf-8")
+
+
+def package_release_sequential(
+    out: Path,
+    *,
+    corpus_path: Path,
+    bm25_documents_path: Path,
+    bm25_postings_path: Path,
+    bm25_stats: dict[str, Any],
+    graph: dict[str, Any] | Path,
+    vectors: dict[str, Any] | Path,
+    source_meta: dict[str, Any],
+    country: dict[str, Any],
+    code_root: Path,
+    normalization_report: dict[str, Any] | None = None,
+    expected_rows: int | None = None,
+) -> dict[str, Any]:
+    """Write release layout one section at a time (never hold corpus+bm25+graph+vectors).
+
+    ``graph`` / ``vectors`` may be in-memory dicts or pickle Paths.
+    Loads and frees each artifact before the next. Prefer this for n>=40k.
+    """
+    from .mem import checkpoint, log_mem
+
+    def _load_obj(obj_or_path):
+        if isinstance(obj_or_path, (str, Path)):
+            p = Path(obj_or_path)
+            with p.open("rb") as f:
+                return pickle.load(f)
+        return obj_or_path
+
+    if out.exists():
+        shutil.rmtree(out)
+    out.mkdir(parents=True, exist_ok=True)
+    indexes_dir = out / "indexes"
+    indexes_dir.mkdir(parents=True, exist_ok=True)
+    log_mem("package_seq_start")
+
+    # --- corpus ---
+    corpus = pd.read_parquet(corpus_path)
+    if expected_rows is not None and len(corpus) != expected_rows:
+        raise ValueError(f"corpus rows {len(corpus)} != expected {expected_rows}")
+    n_laws = int((corpus["record_type"] == "law").sum()) if "record_type" in corpus else 0
+    n_articles = int((corpus["record_type"] == "article").sum()) if "record_type" in corpus else 0
+    corpus_rows = int(len(corpus))
+    corpus_idx = write_sharded(
+        corpus, out / "data" / "corpus", "data/corpus",
+        kind="corpus", key_col="entry_cid", index_col="document_index",
+    )
+    write_parquet(indexes_dir / "corpus_chunks.parquet", _index_df(corpus_idx))
+    del corpus
+    gc.collect()
+    checkpoint("package_corpus_done")
+
+    # --- bm25 documents ---
+    documents = pd.read_parquet(bm25_documents_path)
+    bm25_doc_idx = write_sharded(
+        documents, out / "data" / "bm25" / "documents", "data/bm25/documents",
+        kind="bm25_documents", key_col="entry_cid", index_col="document_index",
+    )
+    write_parquet(indexes_dir / "bm25_document_chunks.parquet", _index_df(bm25_doc_idx))
+    n_bm25_docs = int(len(documents))
+    del documents
+    gc.collect()
+
+    postings = pd.read_parquet(bm25_postings_path)
+    posting_idx = write_sharded(
+        postings, out / "data" / "bm25" / "postings", "data/bm25/postings",
+        kind="bm25_postings", key_col="term",
+    )
+    for row, part_start in zip(posting_idx, range(len(posting_idx))):
+        shard_df = postings.iloc[part_start * MAX_ROWS_PER_FILE : (part_start + 1) * MAX_ROWS_PER_FILE]
+        row["term_count"] = int(shard_df["term"].nunique()) if not shard_df.empty else 0
+        row["posting_count"] = int(shard_df["document_indices"].map(len).sum()) if not shard_df.empty else 0
+        row["token_instance_count"] = row["posting_count"]
+    write_parquet(indexes_dir / "bm25_keyword_shards.parquet", _index_df(posting_idx))
+    n_posting_rows = int(len(postings))
+    del postings
+    gc.collect()
+    checkpoint("package_bm25_done")
+
+    # --- graph ---
+    graph = _load_obj(graph)
+    node_idx = write_sharded(
+        graph["nodes"], out / "data" / "graph" / "nodes", "data/graph/nodes",
+        kind="graph_nodes", key_col="node_cid",
+    )
+    write_parquet(indexes_dir / "graph_node_chunks.parquet", _index_df(node_idx))
+    edge_idx = write_sharded(
+        graph["edges"], out / "data" / "graph" / "edges", "data/graph/edges",
+        kind="graph_edges", key_col="edge_cid",
+    )
+    write_parquet(indexes_dir / "graph_edge_chunks.parquet", _index_df(edge_idx))
+    incoming = graph["incoming"]
+    outgoing = graph["outgoing"]
+    in_idx = write_sharded(
+        incoming if incoming is not None and not incoming.empty else pd.DataFrame(
+            columns=["node_cid", "page_index", "direction"]
+        ),
+        out / "data" / "graph" / "adjacency" / "incoming",
+        "data/graph/adjacency/incoming",
+        kind="graph_incoming_adjacency",
+        key_col="node_cid",
+    )
+    out_idx = write_sharded(
+        outgoing if outgoing is not None and not outgoing.empty else pd.DataFrame(
+            columns=["node_cid", "page_index", "direction"]
+        ),
+        out / "data" / "graph" / "adjacency" / "outgoing",
+        "data/graph/adjacency/outgoing",
+        kind="graph_outgoing_adjacency",
+        key_col="node_cid",
+    )
+    for rows, direction in ((in_idx, "incoming"), (out_idx, "outgoing")):
+        for r in rows:
+            r["direction"] = direction
+            r["adjacency_count"] = r.get("row_count", 0)
+            r["node_count"] = r.get("row_count", 0)
+            r["first_page_index"] = 0
+            r["last_page_index"] = 0
+    write_parquet(indexes_dir / "graph_incoming_adjacency.parquet", _index_df(in_idx))
+    write_parquet(indexes_dir / "graph_outgoing_adjacency.parquet", _index_df(out_idx))
+    gstats = graph["stats"]
+    n_graph_nodes = int(len(graph["nodes"]))
+    n_graph_edges = int(len(graph["edges"]))
+    n_in = int(len(incoming)) if incoming is not None else 0
+    n_out = int(len(outgoing)) if outgoing is not None else 0
+    edge_types = gstats.get("edge_types") or [
+        "HAS_JURISDICTION", "HAS_LANGUAGE", "BELONGS_TO_LAW", "HAS_ARTICLE", "BM25_NEIGHBOR_OF",
+    ]
+    del graph, incoming, outgoing
+    gc.collect()
+    checkpoint("package_graph_done")
+
+    # --- vectors ---
+    vectors = _load_obj(vectors)
+    vectors_df = vectors["vectors"]
+    if "embedding" in vectors_df.columns and vectors_df["embedding"].isna().all():
+        vectors_write = vectors_df.drop(columns=["embedding"])
+        vectors_write["embedding_status"] = "stub_missing"
+    else:
+        vectors_write = vectors_df
+    vec_idx = write_sharded(
+        vectors_write, out / "data" / "vectors", "data/vectors",
+        kind="vectors", key_col="entry_cid", index_col="document_index",
+    )
+    meta_by_cluster = {m["cluster_id"]: m for m in vectors["chunk_meta"]}
+    for r in vec_idx:
+        m = meta_by_cluster.get(r["shard_id"], {})
+        r["centroid"] = m.get("centroid", [])
+        r["shard_centroid"] = m.get("shard_centroid", [])
+        r["centroid_min_score"] = m.get("centroid_min_score", 0.0)
+        r["centroid_shard_count"] = m.get("centroid_shard_count", 1)
+        r["chunk_in_cluster"] = m.get("chunk_in_cluster", 0)
+        r["cluster_id"] = m.get("cluster_id", r["shard_id"])
+        r["dimension"] = 384
+        r["model_name"] = "thenlper/gte-small"
+        if m.get("stub"):
+            r["stub"] = True
+            r["stub_reason"] = m.get("stub_reason", "")
+    write_parquet(indexes_dir / "vector_chunks.parquet", _index_df(vec_idx))
+    vstats = vectors["stats"]
+    n_vectors = int(len(vectors_df))
+    del vectors, vectors_df, vectors_write
+    gc.collect()
+    checkpoint("package_vectors_done")
+
+    # --- bundle code ---
+    pkg_src = Path(__file__).resolve().parent
+    dest_pkg = out / "country_laws_ir"
+    shutil.copytree(
+        pkg_src, dest_pkg, dirs_exist_ok=True,
+        ignore=shutil.ignore_patterns("__pycache__", "*.pyc", ".venv"),
+    )
+    scripts_dir = out / "scripts"
+    scripts_dir.mkdir(exist_ok=True)
+    for name in (
+        "build_country_laws_ir.py", "normalize_country_laws.py",
+        "query_country_laws_hf.py", "query_country_laws_ir.py", "generate_country_laws_ir.py",
+    ):
+        src = code_root / "scripts" / name
+        if src.exists():
+            shutil.copy2(src, scripts_dir / name)
+    shutil.copy2(pkg_src / "normalize.py", out / "normalize.py")
+    shutil.copy2(pkg_src / "query.py", out / "query.py")
+    shutil.copy2(pkg_src / "build.py", out / "build.py")
+    hub_id = target_repo(country["slug"])
+    _write_skill(out, country, hub_id=hub_id)
+
+    reports_dir = out / "reports"
+    reports_dir.mkdir(exist_ok=True)
+    if normalization_report is not None:
+        payload = json.dumps(normalization_report, indent=2, ensure_ascii=False) + "\n"
+        (out / "normalization_report.json").write_text(payload, encoding="utf-8")
+        (reports_dir / "normalization.json").write_text(payload, encoding="utf-8")
+
+    counts = {
+        "bm25_document_chunks": len(bm25_doc_idx),
+        "bm25_documents": n_bm25_docs,
+        "bm25_keyword_shards": len(posting_idx),
+        "bm25_posting_rows": n_posting_rows,
+        "bm25_postings": int(bm25_stats["n_postings"]),
+        "bm25_terms": int(bm25_stats["n_terms"]),
+        "corpus_chunks": len(corpus_idx),
+        "corpus_rows": corpus_rows,
+        "graph_edge_chunks": len(edge_idx),
+        "graph_edges": n_graph_edges,
+        "graph_incoming_adjacency_edges": n_graph_edges,
+        "graph_incoming_adjacency_rows": n_in,
+        "graph_incoming_adjacency_shards": len(in_idx),
+        "graph_node_chunks": len(node_idx),
+        "graph_nodes": n_graph_nodes,
+        "graph_outgoing_adjacency_edges": n_graph_edges,
+        "graph_outgoing_adjacency_rows": n_out,
+        "graph_outgoing_adjacency_shards": len(out_idx),
+        "vector_chunks": len(vec_idx),
+        "vector_rows": n_vectors,
+        "n_laws": n_laws,
+        "n_articles": n_articles,
+    }
+
+    def idx_desc(name: str) -> dict[str, Any]:
+        path = indexes_dir / name
+        return file_descriptor(path, f"indexes/{name}")
+
+    manifest = {
+        "schema_version": SCHEMA_VERSION,
+        "layout_family": LAYOUT_FAMILY,
+        "packager_version": __version__,
+        "primary_key": "entry_cid",
+        "dataset_id": source_meta["source_dataset"],
+        "dataset_repo_id": hub_id,
+        "dataset_revision": source_meta["source_revision"],
+        "country": country,
+        "disclaimer": "Research snapshot. Not legal advice. The official gazette / authentic source prevails.",
+        "bm25": {k: bm25_stats[k] for k in (
+            "k1", "b", "title_weight", "body_weight", "average_document_length",
+            "tokenizer", "max_query_terms", "posting_rows_per_record", "terms_per_shard",
+        ) if k in bm25_stats},
+        "counts": counts,
+        "parquet": {
+            "compression": "zstd",
+            "compression_level": 6,
+            "max_rows_per_file": MAX_ROWS_PER_FILE,
+            "row_group_size": MAX_ROWS_PER_FILE,
+        },
+        "graph": {
+            "adjacency_pointers_per_row": ADJ_POINTERS_PER_ROW,
+            "adjacency_pointers_per_shard": ADJ_POINTERS_PER_SHARD,
+            "directions": ["incoming", "outgoing"],
+            "max_remote_walk_depth": 8,
+            "ordering": "score_desc_nulls_last",
+            "edge_types": edge_types,
+        },
+        "vector": vstats,
+        "canonical_fields": [
+            "entry_cid", "law_cid", "record_type", "jurisdiction", "language",
+            "instrument_id", "instrument_title", "article_number", "article_title",
+            "title", "body", "source_url", "snapshot_date", "coverage", "license",
+            "collector", "source_dataset", "source_revision",
+        ],
+        "input_sha256": {
+            "laws.parquet": source_meta.get("laws_sha256"),
+            "articles.parquet": source_meta.get("articles_sha256"),
+        },
+        "model_id": (vstats or {}).get("model_name", "thenlper/gte-small"),
+        "cid": {
+            "codec": "raw",
+            "hash": "sha2-256",
+            "multibase": "base32",
+            "payload": "json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(',', ':')).encode('utf-8')",
+        },
+        "normalization": normalization_report or {},
+        "packaging_mode": "sequential_spill",
+        "schema_mapping": {
+            "laws": {
+                "id": "instrument_id", "title": "instrument_title", "text": "body",
+                "article_count_dtype_source": source_meta.get("article_count_dtype"),
+            },
+            "articles": {
+                "id": "source_id / article identity", "law_id": "instrument_id",
+                "title": "article_title", "text": "body",
+            },
+            "unit_policy": "prefer articles; fall back to law-level when articles empty",
+            "required_law_columns": ["id", "title", "text"],
+            "required_article_columns": ["id", "law_id", "title", "text"],
+            "fail_closed": True,
+            "notes": (
+                "Malta and Germany share the same column names. Drift: Malta article_count "
+                "is int64, Germany article_count is int32; Germany eli is often null. "
+                "Identifiers are never invented. Layout matches SkillCenter HF release / publicus-ir family."
+            ),
+        },
+        "indexes": {
+            "bm25_document_chunks": idx_desc("bm25_document_chunks.parquet"),
+            "bm25_keyword_shards": idx_desc("bm25_keyword_shards.parquet"),
+            "corpus_chunks": idx_desc("corpus_chunks.parquet"),
+            "graph_edge_chunks": idx_desc("graph_edge_chunks.parquet"),
+            "graph_incoming_adjacency": idx_desc("graph_incoming_adjacency.parquet"),
+            "graph_node_chunks": idx_desc("graph_node_chunks.parquet"),
+            "graph_outgoing_adjacency": idx_desc("graph_outgoing_adjacency.parquet"),
+            "vector_chunks": idx_desc("vector_chunks.parquet"),
+        },
+        "source": source_meta,
+    }
+    (out / "manifest.json").write_text(
+        json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    _write_readme(out, country, source_meta, counts, bm25_stats, gstats, vstats, hub_id)
+    _write_gitattributes(out)
+    checkpoint("package_seq_done")
+    return manifest
+
+
+def package_from_spill(
+    out: Path,
+    spill: Path,
+    corpus_path: Path,
+    source_meta: dict[str, Any],
+    country: dict[str, Any],
+    code_root: Path,
+    normalization_report: dict[str, Any] | None = None,
+    expected_rows: int | None = None,
+) -> dict[str, Any]:
+    """Package from spill dir artifacts: bm25_*.parquet, bm25_stats.pkl, graph.pkl, vectors.pkl."""
+    import pickle as _pickle
+
+    spill = Path(spill)
+    stats_path = spill / "bm25_stats.pkl"
+    with stats_path.open("rb") as f:
+        bm25_stats = _pickle.load(f)
+    return package_release_sequential(
+        out,
+        corpus_path=Path(corpus_path),
+        bm25_documents_path=spill / "bm25_documents.parquet",
+        bm25_postings_path=spill / "bm25_postings.parquet",
+        bm25_stats=bm25_stats,
+        graph=spill / "graph.pkl",
+        vectors=spill / "vectors.pkl",
+        source_meta=source_meta,
+        country=country,
+        code_root=Path(code_root),
+        normalization_report=normalization_report,
+        expected_rows=expected_rows,
+    )

country_laws_ir/parquet_io.py

@@ -0,0 +1,83 @@
+"""ZSTD parquet shard writer matching skillcenter-huggingface-release/v3."""
+
+from __future__ import annotations
+
+import math
+from pathlib import Path
+from typing import Any, Iterable
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+from . import MAX_ROWS_PER_FILE, SCHEMA_VERSION
+from .cidutil import file_descriptor
+
+COMPRESSION = "zstd"
+COMPRESSION_LEVEL = 6
+
+
+def write_parquet(path: Path, df: pd.DataFrame) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    table = pa.Table.from_pandas(df, preserve_index=False)
+    pq.write_table(
+        table,
+        path,
+        compression=COMPRESSION,
+        compression_level=COMPRESSION_LEVEL,
+        row_group_size=min(MAX_ROWS_PER_FILE, max(len(df), 1)),
+        use_dictionary=True,
+    )
+
+
+def shard_frames(df: pd.DataFrame, max_rows: int = MAX_ROWS_PER_FILE) -> list[pd.DataFrame]:
+    if df.empty:
+        return [df.copy()]
+    n = int(math.ceil(len(df) / max_rows))
+    return [df.iloc[i * max_rows : (i + 1) * max_rows].copy() for i in range(n)]
+
+
+def write_sharded(
+    df: pd.DataFrame,
+    out_dir: Path,
+    relative_dir: str,
+    kind: str,
+    key_col: str | None = None,
+    index_col: str | None = None,
+    extra_index: dict | None = None,
+) -> list[dict[str, Any]]:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    shards = shard_frames(df)
+    rows: list[dict[str, Any]] = []
+    for i, part in enumerate(shards):
+        name = f"part-{i:06d}.parquet"
+        path = out_dir / name
+        write_parquet(path, part)
+        rel = f"{relative_dir}/{name}"
+        first_key = last_key = ""
+        if key_col and key_col in part.columns and not part.empty:
+            keys = part[key_col].astype(str)
+            first_key = keys.iloc[0]
+            last_key = keys.iloc[-1]
+        start_idx = end_idx = 0
+        if index_col and index_col in part.columns and not part.empty:
+            start_idx = int(part[index_col].iloc[0])
+            end_idx = int(part[index_col].iloc[-1])
+        desc = file_descriptor(
+            path,
+            rel,
+            extra={
+                "shard_id": i,
+                "kind": kind,
+                "row_count": int(len(part)),
+                "first_key": first_key,
+                "last_key": last_key,
+                "start_document_index": start_idx,
+                "end_document_index": end_idx,
+                "schema_version": SCHEMA_VERSION,
+            },
+        )
+        if extra_index:
+            desc.update(extra_index)
+        rows.append(desc)
+    return rows

country_laws_ir/query.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""Thin-client query for country-laws IR releases (local dir)."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+
+K1 = 1.2
+B = 0.75
+TITLE_WEIGHT = 5.0
+BODY_WEIGHT = 1.0
+MAX_QUERY_TERMS = 64
+
+
+def tokenize(text: str) -> list[str]:
+    import re
+    import unicodedata
+
+    if not text:
+        return []
+    nfkd = unicodedata.normalize("NFKD", text)
+    folded = "".join(ch for ch in nfkd if not unicodedata.combining(ch)).lower()
+    return re.findall(r"[0-9A-Za-z]+", folded)
+
+
+class Release:
+    def __init__(self, root: Path):
+        self.root = Path(root)
+        self.manifest = json.loads((self.root / "manifest.json").read_text(encoding="utf-8"))
+
+    def _read(self, rel: str) -> pd.DataFrame:
+        path = self.root / rel
+        if path.is_dir():
+            files = sorted(path.glob("*.parquet"))
+            return pd.concat([pd.read_parquet(f) for f in files], ignore_index=True) if files else pd.DataFrame()
+        return pd.read_parquet(path)
+
+    def bm25(self, query: str, top_k: int = 10) -> list[dict]:
+        q_terms = tokenize(query)[:MAX_QUERY_TERMS]
+        if not q_terms:
+            return []
+        shards = pd.read_parquet(self.root / "indexes" / "bm25_keyword_shards.parquet")
+        needed = set()
+        for term in q_terms:
+            hit = shards[(shards["first_key"] <= term) & (shards["last_key"] >= term)]
+            if hit.empty:
+                hit = shards
+            for rel in hit["relative_path"].tolist():
+                needed.add(rel)
+        postings = pd.concat(
+            [pd.read_parquet(self.root / rel) for rel in sorted(needed)],
+            ignore_index=True,
+        )
+        postings = postings[postings["term"].isin(q_terms)]
+        docs = self._read("data/bm25/documents")
+        avgdl = float(self.manifest["bm25"]["average_document_length"]) or 1.0
+        scores: dict[int, float] = defaultdict(float)
+        for rec in postings.itertuples(index=False):
+            idf = float(rec.idf)
+            for di, ttf, btf, dl in zip(
+                rec.document_indices, rec.title_frequencies, rec.body_frequencies, rec.document_lengths
+            ):
+                tf = TITLE_WEIGHT * int(ttf) + BODY_WEIGHT * int(btf)
+                denom = tf + K1 * (1.0 - B + B * (int(dl) / avgdl))
+                if denom:
+                    scores[int(di)] += idf * (tf * (K1 + 1.0)) / denom
+        ranked = sorted(scores.items(), key=lambda kv: kv[1], reverse=True)[:top_k]
+        by_idx = docs.set_index("document_index")
+        out = []
+        for di, score in ranked:
+            row = by_idx.loc[di]
+            out.append(
+                {
+                    "document_index": int(di),
+                    "entry_cid": row["entry_cid"],
+                    "title": row["title"],
+                    "record_type": row["record_type"],
+                    "instrument_id": row.get("instrument_id", row.get("law_id", "")),
+                    "law_cid": row.get("law_cid", ""),
+                    "score": float(score),
+                }
+            )
+        return out
+
+    def vector(self, query: str, top_k: int = 10, candidate_centroids: int = 4, device: str = "cpu") -> list[dict]:
+        status = (self.manifest.get("vector") or {}).get("status")
+        if status == "stub":
+            return [{"error": "vectors are stubbed", "reason": self.manifest["vector"].get("stub_reason")}]
+        from sentence_transformers import SentenceTransformer
+
+        model = SentenceTransformer(self.manifest["vector"]["model_name"], device=device)
+        q = model.encode([query], normalize_embeddings=True, convert_to_numpy=True)[0].astype(np.float32)
+        meta = pd.read_parquet(self.root / "indexes" / "vector_chunks.parquet")
+        cents = np.stack(meta["centroid"].map(lambda c: np.asarray(c, dtype=np.float32)).to_numpy())
+        sims = cents @ q
+        order = np.argsort(-sims)[: max(1, candidate_centroids)]
+        shards = meta.iloc[order]
+        frames = [pd.read_parquet(self.root / rel) for rel in shards["relative_path"].tolist()]
+        vecs = pd.concat(frames, ignore_index=True)
+        if "embedding" not in vecs.columns or vecs["embedding"].isna().all():
+            return [{"error": "vector shard missing embeddings"}]
+        emb = np.stack(vecs["embedding"].map(lambda e: np.asarray(e, dtype=np.float32)).to_numpy())
+        scores = emb @ q
+        top = np.argsort(-scores)[:top_k]
+        out = []
+        for i in top:
+            row = vecs.iloc[int(i)]
+            out.append(
+                {
+                    "document_index": int(row["document_index"]),
+                    "entry_cid": row["entry_cid"],
+                    "title": row["title"],
+                    "record_type": row["record_type"],
+                    "instrument_id": row.get("instrument_id", row.get("law_id", "")),
+                    "score": float(scores[int(i)]),
+                }
+            )
+        return out
+
+    def neighbors(self, node_cid: str, direction: str = "both", limit: int = 25) -> list[dict]:
+        dirs = ["incoming", "outgoing"] if direction == "both" else [direction]
+        hits = []
+        for d in dirs:
+            path = self.root / "data" / "graph" / "adjacency" / d
+            files = sorted(path.glob("*.parquet"))
+            for f in files:
+                df = pd.read_parquet(f)
+                sub = df[df["node_cid"] == node_cid]
+                for rec in sub.itertuples(index=False):
+                    for i, neigh in enumerate(rec.neighbor_cids):
+                        hits.append(
+                            {
+                                "direction": d,
+                                "node_cid": node_cid,
+                                "neighbor_cid": neigh,
+                                "edge_type": rec.edge_types[i] if i < len(rec.edge_types) else "",
+                                "score": rec.scores[i] if rec.scores is not None and i < len(rec.scores) else None,
+                            }
+                        )
+        hits.sort(key=lambda r: (-(r["score"] or 0), r["neighbor_cid"]))
+        return hits[:limit]
+
+
+def _print(rows: list[dict]) -> None:
+    print(json.dumps(rows, indent=2, ensure_ascii=False))
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(description="Query a country-laws IR release")
+    ap.add_argument("--local-dir", required=True, help="Path to local release root")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p_bm = sub.add_parser("bm25")
+    p_bm.add_argument("query")
+    p_bm.add_argument("--top-k", type=int, default=10)
+
+    p_vec = sub.add_parser("vector")
+    p_vec.add_argument("query")
+    p_vec.add_argument("--top-k", type=int, default=10)
+    p_vec.add_argument("--candidate-centroids", type=int, default=4)
+    p_vec.add_argument("--device", default="cpu")
+
+    p_g = sub.add_parser("graph")
+    g_sub = p_g.add_subparsers(dest="graph_cmd", required=True)
+    p_n = g_sub.add_parser("neighbors")
+    p_n.add_argument("node_cid")
+    p_n.add_argument("--direction", default="both", choices=["both", "incoming", "outgoing"])
+    p_n.add_argument("--limit", type=int, default=25)
+
+    args = ap.parse_args(argv)
+    rel = Release(Path(args.local_dir))
+    if args.cmd == "bm25":
+        _print(rel.bm25(args.query, top_k=args.top_k))
+    elif args.cmd == "vector":
+        _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))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

country_laws_ir/schema.py

@@ -0,0 +1,128 @@
+"""Fail-closed schema mapping for endomorphosis/ipfs_*_laws parquet tables.
+
+Verified 2026-09-03 against Malta (pilot) and Germany (column-drift check):
+
+Laws columns (both countries):
+  id, title, text, source_url, source_type, jurisdiction, country, language,
+  eli, date, date_issued, retrieved_at, license, law_status, identifier,
+  official_identifier, article_count, json_path, metadata_json
+
+Drift: Malta article_count is int64; Germany article_count is int32.
+       Germany eli is frequently null. Neither is a missing identifier.
+
+Articles columns (both countries; Malta snapshot has 0 rows):
+  law_id, id, title, text, source_url, document_number, article_number,
+  record_type, metadata_json
+
+Required identity columns are NOT invented. Missing required identifiers
+fail the build.
+"""
+
+from __future__ import annotations
+
+REQUIRED_LAW_COLUMNS = ("id", "title", "text")
+REQUIRED_ARTICLE_COLUMNS = ("id", "law_id", "title", "text")
+
+OPTIONAL_LAW_COLUMNS = (
+    "source_url",
+    "source_type",
+    "jurisdiction",
+    "country",
+    "language",
+    "eli",
+    "date",
+    "date_issued",
+    "retrieved_at",
+    "license",
+    "law_status",
+    "identifier",
+    "official_identifier",
+    "article_count",
+    "json_path",
+    "metadata_json",
+)
+
+OPTIONAL_ARTICLE_COLUMNS = (
+    "source_url",
+    "document_number",
+    "article_number",
+    "record_type",
+    "metadata_json",
+)
+
+# Canonical field mapping used in the CID-keyed corpus.
+LAW_FIELD_MAP = {
+    "source_id": "id",
+    "title": "title",
+    "body": "text",
+    "source_url": "source_url",
+    "source_type": "source_type",
+    "jurisdiction": "jurisdiction",
+    "country": "country",
+    "language": "language",
+    "eli": "eli",
+    "date": "date",
+    "date_issued": "date_issued",
+    "retrieved_at": "retrieved_at",
+    "license_expression": "license",
+    "law_status": "law_status",
+    "identifier": "identifier",
+    "official_identifier": "official_identifier",
+    "article_count": "article_count",
+    "metadata_json": "metadata_json",
+}
+
+ARTICLE_FIELD_MAP = {
+    "source_id": "id",
+    "law_id": "law_id",
+    "title": "title",
+    "body": "text",
+    "source_url": "source_url",
+    "document_number": "document_number",
+    "article_number": "article_number",
+    "record_type_src": "record_type",
+    "metadata_json": "metadata_json",
+}
+
+
+class SchemaError(ValueError):
+    pass
+
+
+def _cols(df) -> set[str]:
+    return set(map(str, df.columns))
+
+
+def validate_laws(df) -> None:
+    missing = [c for c in REQUIRED_LAW_COLUMNS if c not in _cols(df)]
+    if missing:
+        raise SchemaError(
+            f"laws.parquet missing required identifier/content columns {missing}; "
+            f"present={sorted(_cols(df))}. Fail closed — will not invent ids."
+        )
+    null_ids = int(df["id"].isna().sum()) if "id" in df.columns else len(df)
+    empty_ids = int((df["id"].astype(str).str.strip() == "").sum()) if "id" in df.columns else 0
+    if null_ids or empty_ids:
+        raise SchemaError(
+            f"laws.parquet has {null_ids} null and {empty_ids} empty id values. Fail closed."
+        )
+
+
+def validate_articles(df) -> None:
+    if df is None or df.empty:
+        return
+    missing = [c for c in REQUIRED_ARTICLE_COLUMNS if c not in _cols(df)]
+    if missing:
+        raise SchemaError(
+            f"articles.parquet missing required identifier/content columns {missing}; "
+            f"present={sorted(_cols(df))}. Fail closed — will not invent ids."
+        )
+    null_ids = int(df["id"].isna().sum())
+    null_law = int(df["law_id"].isna().sum())
+    empty_ids = int((df["id"].astype(str).str.strip() == "").sum())
+    empty_law = int((df["law_id"].astype(str).str.strip() == "").sum())
+    if null_ids or empty_ids or null_law or empty_law:
+        raise SchemaError(
+            f"articles.parquet has null/empty identifiers "
+            f"(id null={null_ids} empty={empty_ids}; law_id null={null_law} empty={empty_law}). Fail closed."
+        )

country_laws_ir/spill.py

@@ -0,0 +1,763 @@
+"""Disk-spill helpers for large country IR builds (SQLite FTS neighbors + BM25 TF).
+
+Design (CoS / DO OOM lesson):
+- Embeddings: checkpointed .npy via vectors.encode_corpus (unchanged).
+- Neighbors for n >= SQLITE_THRESHOLD (40k): SQLite FTS5 title-only MATCH streaming
+  into neighbor_*.pkl shards under cache/<slug>_bm25_spill/ — never hold full
+  neighbor matrix in RAM during streaming.
+- BM25 TF: stream tokenize → SQLite WITHOUT ROWID → posting parquet parts.
+- Package: use package.package_release_sequential / package_from_spill so corpus,
+  bm25, graph, vectors are never all resident together; neighbor edges can be
+  streamed from shards into graph then spilled as graph.pkl.
+
+Resume-safe: existing FTS DB / neighbor shards / bm25_*.parquet are reused when
+row counts match.
+"""
+from __future__ import annotations
+
+import gc
+import json
+import math
+import pickle
+import sqlite3
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, Callable, Iterable, Iterator
+
+import numpy as np
+import pandas as pd
+import pyarrow.parquet as pq
+
+from . import SCHEMA_VERSION
+from .bm25 import (
+    B,
+    BODY_WEIGHT,
+    K1,
+    POSTING_ROWS_PER_RECORD,
+    TERMS_PER_SHARD,
+    TITLE_WEIGHT,
+)
+from .graph import _adjacency, _edge, build_graph
+from .mem import MemAbort, checkpoint, log_mem
+from .tokenize import tokenize
+
+SQLITE_THRESHOLD = 40_000
+BATCH = 256
+NEIGHBOR_SHARD = 5_000
+NEIGHBOR_K = 8
+DF_CAP = 1500
+MAX_QTERMS = 8
+TITLE_W = TITLE_WEIGHT
+BODY_W = BODY_WEIGHT
+
+
+def spill_dir_for(slug: str, cache: Path) -> Path:
+    return Path(cache) / f"{slug}_bm25_spill"
+
+
+def spill_pickle(path: Path, obj: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    with tmp.open("wb") as f:
+        pickle.dump(obj, f, protocol=pickle.HIGHEST_PROTOCOL)
+    tmp.replace(path)
+
+
+def load_pickle(path: Path) -> Any:
+    with path.open("rb") as f:
+        return pickle.load(f)
+
+
+def quote_fts_term(term: str) -> str:
+    return '"' + term.replace('"', '""') + '"'
+
+
+def _idf(n_docs: int, df: int) -> float:
+    return math.log((n_docs - df + 0.5) / (df + 0.5) + 1.0)
+
+
+def sqlite_ready(db_path: Path, expected: int) -> bool:
+    if not db_path.is_file():
+        return False
+    try:
+        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+        n = int(conn.execute("SELECT COUNT(*) FROM documents").fetchone()[0])
+        conn.close()
+        return n == expected
+    except Exception:
+        return False
+
+
+def build_sqlite_fts(
+    corpus_path: Path,
+    db_path: Path,
+    expected: int,
+    *,
+    batch: int = BATCH,
+    log: Callable[[str], None] | None = None,
+) -> int:
+    """Contentless FTS5 over title+body; documents table holds query_text."""
+    if db_path.exists():
+        db_path.unlink()
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(db_path))
+    try:
+        conn.executescript(
+            """
+            PRAGMA journal_mode = OFF;
+            PRAGMA synchronous = OFF;
+            PRAGMA temp_store = MEMORY;
+            PRAGMA locking_mode = EXCLUSIVE;
+            PRAGMA page_size = 32768;
+            CREATE TABLE documents (
+                document_index INTEGER PRIMARY KEY,
+                entry_cid TEXT NOT NULL UNIQUE,
+                title TEXT NOT NULL,
+                query_text TEXT NOT NULL
+            );
+            CREATE VIRTUAL TABLE documents_fts USING fts5(
+                title,
+                body,
+                content='',
+                columnsize=1,
+                tokenize='unicode61 remove_diacritics 2'
+            );
+            """
+        )
+        pf = pq.ParquetFile(corpus_path)
+        n = 0
+        meta_batch: list[tuple] = []
+        fts_batch: list[tuple] = []
+        conn.execute("BEGIN")
+        for batch_tbl in pf.iter_batches(
+            batch_size=batch, columns=["document_index", "entry_cid", "title", "body"]
+        ):
+            cols = batch_tbl.to_pydict()
+            for i in range(len(cols["document_index"])):
+                di = int(cols["document_index"][i])
+                title = str(cols["title"][i] or "")
+                body = str(cols["body"][i] or "")
+                cid = str(cols["entry_cid"][i])
+                qtext = title.strip() if title.strip() else body[:800]
+                meta_batch.append((di, cid, title, qtext))
+                fts_batch.append((di + 1, title, body))
+                if len(meta_batch) >= batch:
+                    conn.executemany(
+                        "INSERT INTO documents(document_index, entry_cid, title, query_text) "
+                        "VALUES (?,?,?,?)",
+                        meta_batch,
+                    )
+                    conn.executemany(
+                        "INSERT INTO documents_fts(rowid, title, body) VALUES (?,?,?)",
+                        fts_batch,
+                    )
+                    n += len(meta_batch)
+                    meta_batch.clear()
+                    fts_batch.clear()
+                    if n % 20_000 == 0:
+                        checkpoint(f"fts_insert@{n}", row=n, every_n=20_000, log=log)
+                        gc.collect()
+        if meta_batch:
+            conn.executemany(
+                "INSERT INTO documents(document_index, entry_cid, title, query_text) "
+                "VALUES (?,?,?,?)",
+                meta_batch,
+            )
+            conn.executemany(
+                "INSERT INTO documents_fts(rowid, title, body) VALUES (?,?,?)",
+                fts_batch,
+            )
+            n += len(meta_batch)
+        conn.commit()
+        conn.execute("INSERT INTO documents_fts(documents_fts) VALUES('optimize')")
+        conn.commit()
+        conn.execute(
+            "CREATE VIRTUAL TABLE documents_vocab USING fts5vocab(documents_fts, 'row')"
+        )
+        conn.commit()
+        got = int(conn.execute("SELECT COUNT(*) FROM documents").fetchone()[0])
+        assert got == n == expected, (got, n, expected)
+        return n
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+        gc.collect()
+
+
+def load_df_map(conn: sqlite3.Connection, df_cap: int = DF_CAP) -> dict[str, int]:
+    df_map: dict[str, int] = {}
+    for term, doc in conn.execute(
+        "SELECT term, doc FROM documents_vocab WHERE doc <= ?", (df_cap,)
+    ):
+        df_map[str(term)] = int(doc)
+    return df_map
+
+
+def select_query_terms(query_text: str, df_map: dict[str, int]) -> list[str]:
+    toks = tokenize(query_text)[:24]
+    seen: set[str] = set()
+    cands: list[tuple[int, str]] = []
+    for t in toks:
+        if t in seen or len(t) < 2:
+            continue
+        seen.add(t)
+        if t not in df_map:
+            continue
+        cands.append((df_map[t], t))
+    cands.sort()
+    return [t for _, t in cands[:MAX_QTERMS]]
+
+
+def stream_neighbors_to_shards(
+    db_path: Path,
+    spill: Path,
+    n_docs: int,
+    *,
+    k: int = NEIGHBOR_K,
+    shard: int = NEIGHBOR_SHARD,
+    batch: int = BATCH,
+    df_cap: int = DF_CAP,
+    resume: bool = True,
+    log: Callable[[str], None] | None = None,
+) -> list[Path]:
+    """Stream FTS5 title-only neighbors into neighbor_START_END.pkl shards.
+
+    Does not assemble the full neighbor list. Resume skips shards already on disk
+    whose end index is covered (contiguous from 0).
+    """
+    spill.mkdir(parents=True, exist_ok=True)
+    existing = sorted(spill.glob("neighbors_*.pkl"))
+    buf_start = 0
+    shard_paths: list[Path] = []
+    if resume and existing:
+        # Contiguous cover from 0
+        covered = 0
+        for sp in existing:
+            parts = sp.stem.split("_")
+            # neighbors_000000_005000
+            try:
+                start_i, end_i = int(parts[1]), int(parts[2])
+            except (IndexError, ValueError):
+                continue
+            if start_i != covered:
+                break
+            shard_paths.append(sp)
+            covered = end_i
+        buf_start = covered
+        if buf_start >= n_docs:
+            if log:
+                log(f"neighbors resume complete {buf_start}/{n_docs}")
+            return shard_paths
+        if log:
+            log(f"neighbors resume from {buf_start}/{n_docs} shards={len(shard_paths)}")
+        # Drop non-contiguous leftover shards beyond covered
+        for sp in existing:
+            if sp not in shard_paths:
+                sp.unlink(missing_ok=True)
+    else:
+        for sp in existing:
+            sp.unlink(missing_ok=True)
+
+    conn_rw = sqlite3.connect(str(db_path))
+    row = conn_rw.execute(
+        "SELECT name FROM sqlite_master WHERE name='documents_vocab'"
+    ).fetchone()
+    if row is None:
+        conn_rw.execute(
+            "CREATE VIRTUAL TABLE documents_vocab USING fts5vocab(documents_fts, 'row')"
+        )
+        conn_rw.commit()
+    df_map = load_df_map(conn_rw, df_cap)
+    conn_rw.close()
+    spill_pickle(spill / "df_map_meta.pkl", {"n_rare": len(df_map), "df_cap": df_cap})
+    if log:
+        log(f"vocab rare_terms={len(df_map)} df_cap={df_cap}")
+
+    conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+    conn.row_factory = sqlite3.Row
+    buf: list = []
+    done = buf_start
+    score_sql = f"-bm25(documents_fts, {TITLE_W}, {BODY_W})"
+    last_idx = buf_start - 1
+    try:
+        while True:
+            rows = conn.execute(
+                "SELECT document_index, entry_cid, query_text FROM documents "
+                "WHERE document_index > ? ORDER BY document_index LIMIT ?",
+                (last_idx, batch),
+            ).fetchall()
+            if not rows:
+                break
+            for row in rows:
+                di = int(row["document_index"])
+                terms = select_query_terms(str(row["query_text"]), df_map)
+                if not terms:
+                    neigh: list = []
+                else:
+                    expr = " OR ".join("title : " + quote_fts_term(t) for t in terms)
+                    sql = (
+                        "SELECT d.document_index, " + score_sql + " AS score "
+                        "FROM documents_fts "
+                        "JOIN documents AS d ON d.document_index = documents_fts.rowid - 1 "
+                        "WHERE documents_fts MATCH ? AND d.document_index != ? "
+                        "ORDER BY score DESC, d.document_index LIMIT ?"
+                    )
+                    hits = conn.execute(sql, (expr, di, k)).fetchall()
+                    neigh = [
+                        (int(h["document_index"]), max(0.0, float(h["score"])), list(terms)[:4])
+                        for h in hits
+                    ]
+                while buf_start + len(buf) < di:
+                    buf.append([])
+                buf.append(neigh)
+                last_idx = di
+                done += 1
+                if len(buf) >= shard:
+                    end = buf_start + len(buf)
+                    sp = spill / f"neighbors_{buf_start:06d}_{end:06d}.pkl"
+                    spill_pickle(sp, buf)
+                    shard_paths.append(sp)
+                    checkpoint(
+                        f"neighbors_shard_{buf_start}_{end}",
+                        log=log,
+                    )
+                    buf_start = end
+                    buf = []
+                    gc.collect()
+                if done % 5_000 == 0:
+                    checkpoint(f"neighbors_stream", row=done, every_n=5_000, log=log)
+        if buf:
+            end = buf_start + len(buf)
+            sp = spill / f"neighbors_{buf_start:06d}_{end:06d}.pkl"
+            spill_pickle(sp, buf)
+            shard_paths.append(sp)
+            if log:
+                log(f"neighbors shard final {buf_start}:{end}/{n_docs}")
+        if log:
+            log(f"bm25 neighbors streamed done={done} n_docs={n_docs} shards={len(shard_paths)}")
+        return shard_paths
+    finally:
+        conn.close()
+        del df_map
+        gc.collect()
+
+
+def iter_neighbor_shards(spill: Path) -> Iterator[tuple[int, list]]:
+    """Yield (start_index, shard_list) without loading all shards."""
+    paths = sorted(spill.glob("neighbors_*.pkl"))
+    for sp in paths:
+        parts = sp.stem.split("_")
+        start_i = int(parts[1])
+        yield start_i, load_pickle(sp)
+
+
+def assemble_neighbors_streaming(spill: Path, n_docs: int) -> list:
+    """Assemble only when unavoidable; prefer build_graph_from_neighbor_shards."""
+    neighbors: list = []
+    for start_i, part in iter_neighbor_shards(spill):
+        while len(neighbors) < start_i:
+            neighbors.append([])
+        neighbors.extend(part)
+        del part
+        gc.collect()
+    while len(neighbors) < n_docs:
+        neighbors.append([])
+    if len(neighbors) > n_docs:
+        neighbors = neighbors[:n_docs]
+    return neighbors
+
+
+def neighbors_via_sqlite(
+    corpus_path: Path,
+    spill: Path,
+    n_docs: int,
+    *,
+    k: int = NEIGHBOR_K,
+    resume: bool = True,
+    log: Callable[[str], None] | None = None,
+) -> list[Path]:
+    """Ensure FTS DB + neighbor shards; return shard paths (not full list)."""
+    spill.mkdir(parents=True, exist_ok=True)
+    db_path = spill / "fts.sqlite"
+    if not sqlite_ready(db_path, n_docs):
+        if db_path.exists():
+            db_path.unlink()
+        if log:
+            log(f"building sqlite fts n={n_docs} -> {db_path}")
+        build_sqlite_fts(corpus_path, db_path, n_docs, log=log)
+    else:
+        if log:
+            log(f"reusing sqlite fts n={n_docs} path={db_path}")
+    return stream_neighbors_to_shards(
+        db_path, spill, n_docs, k=k, resume=resume, log=log
+    )
+
+
+def build_graph_from_neighbor_shards(
+    corpus: pd.DataFrame,
+    spill: Path,
+    *,
+    log: Callable[[str], None] | None = None,
+) -> dict[str, Any]:
+    """Build graph without holding the full neighbor list.
+
+    Structural edges first (neighbors=[]), then stream BM25_NEIGHBOR_OF from shards
+    and recompute adjacency once.
+    """
+    n = len(corpus)
+    # Structural + facets only
+    graph = build_graph(corpus, [[] for _ in range(n)])
+    cid_by_idx = corpus["entry_cid"].tolist()
+    extra_edges: list[dict[str, Any]] = []
+    seen = 0
+    for start_i, part in iter_neighbor_shards(spill):
+        for offset, neigh in enumerate(part):
+            i = start_i + offset
+            if i >= n:
+                break
+            src = cid_by_idx[i]
+            for item in neigh:
+                if len(item) == 3:
+                    j, score, terms = item
+                else:
+                    j, score = item[0], item[1]
+                    terms = []
+                tgt = cid_by_idx[int(j)]
+                extra_edges.append(
+                    _edge(
+                        src,
+                        "BM25_NEIGHBOR_OF",
+                        tgt,
+                        "bm25-okapi",
+                        float(score),
+                        {"k": 8, "neighbor_index": int(j)},
+                        matched_terms=list(terms),
+                    )
+                )
+        seen += len(part)
+        del part
+        if len(extra_edges) >= 50_000:
+            # Flush into edges df incrementally
+            add = pd.DataFrame(extra_edges)
+            graph["edges"] = pd.concat([graph["edges"], add], ignore_index=True)
+            extra_edges.clear()
+            del add
+            gc.collect()
+            checkpoint(f"graph_neighbor_edges@{seen}", row=seen, every_n=50_000, log=log)
+    if extra_edges:
+        add = pd.DataFrame(extra_edges)
+        graph["edges"] = pd.concat([graph["edges"], add], ignore_index=True)
+        del add, extra_edges
+        gc.collect()
+
+    edges_df = graph["edges"]
+    if not edges_df.empty:
+        edges_df = edges_df.drop_duplicates("edge_cid").reset_index(drop=True)
+        edges_df = edges_df.sort_values(
+            ["edge_type", "source_cid", "target_cid"]
+        ).reset_index(drop=True)
+    graph["edges"] = edges_df
+    node_type = {r["node_cid"]: r["node_type"] for r in graph["nodes"].to_dict("records")}
+    incoming, outgoing = _adjacency(edges_df, node_type)
+    graph["incoming"] = incoming
+    graph["outgoing"] = outgoing
+    graph["stats"] = {
+        "n_nodes": int(len(graph["nodes"])),
+        "n_edges": int(len(edges_df)),
+        "n_doc_nodes": int(
+            graph["nodes"]["node_type"].isin(["law_entry", "article", "law"]).sum()
+        ),
+        "n_facet_nodes": int(
+            graph["nodes"]["node_type"].astype(str).str.startswith("facet_").sum()
+        ),
+        "edge_types": sorted(edges_df["edge_type"].unique().tolist())
+        if not edges_df.empty
+        else [],
+    }
+    if log:
+        log(
+            f"graph from shards nodes={graph['stats']['n_nodes']} "
+            f"edges={graph['stats']['n_edges']}"
+        )
+    return graph
+
+
+def build_bm25_tf_spill(
+    corpus_path: Path,
+    spill: Path,
+    n_docs: int,
+    *,
+    batch: int = 512,
+    log: Callable[[str], None] | None = None,
+) -> dict[str, Any]:
+    """Stream tokenize corpus → SQLite TF → bm25_documents/postings parquet + stats.
+
+    Resume: if bm25_documents.parquet + bm25_postings.parquet + bm25_stats.pkl exist
+    with matching n_docs, reuse.
+    """
+    spill.mkdir(parents=True, exist_ok=True)
+    docs_path = spill / "bm25_documents.parquet"
+    post_path = spill / "bm25_postings.parquet"
+    stats_path = spill / "bm25_stats.pkl"
+    if docs_path.is_file() and post_path.is_file() and stats_path.is_file():
+        stats = load_pickle(stats_path)
+        if int(stats.get("n_docs", -1)) == n_docs:
+            if log:
+                log(f"reusing bm25 spill n_docs={n_docs}")
+            return {"stats": stats, "documents": docs_path, "postings": post_path}
+
+    bm25_sql = spill / "bm25_tf.sqlite"
+    if bm25_sql.exists():
+        bm25_sql.unlink()
+    conn = sqlite3.connect(str(bm25_sql))
+    conn.execute("PRAGMA journal_mode=OFF")
+    conn.execute("PRAGMA synchronous=OFF")
+    conn.execute("PRAGMA temp_store=MEMORY")
+    conn.execute("PRAGMA locking_mode=EXCLUSIVE")
+    conn.execute(
+        "CREATE TABLE tf (term TEXT NOT NULL, doc INTEGER NOT NULL, "
+        "ttf INTEGER NOT NULL, btf INTEGER NOT NULL, PRIMARY KEY(term, doc)) WITHOUT ROWID"
+    )
+    title_len = np.zeros(n_docs, dtype=np.int32)
+    body_len = np.zeros(n_docs, dtype=np.int32)
+    meta_path = spill / "doc_meta_rows.parquet"
+    meta_path.unlink(missing_ok=True)
+    meta_buf: list[dict] = []
+    pf = pq.ParquetFile(corpus_path)
+    schema_names = set(pf.schema_arrow.names)
+    cols = [
+        c
+        for c in [
+            "document_index",
+            "entry_cid",
+            "law_cid",
+            "instrument_id",
+            "law_id",
+            "source_id",
+            "title",
+            "instrument_title",
+            "article_number",
+            "article_title",
+            "record_type",
+            "language",
+            "jurisdiction",
+            "body",
+        ]
+        if c in schema_names
+    ]
+    processed = 0
+    batch_rows: list[tuple] = []
+    conn.execute("BEGIN")
+    for batch_tbl in pf.iter_batches(batch_size=batch, columns=cols):
+        d = batch_tbl.to_pydict()
+        m = len(d["document_index"])
+        for i in range(m):
+            di = int(d["document_index"][i])
+            title = str((d.get("title") or [""])[i] or "")
+            body = str((d.get("body") or [""])[i] or "")
+            tt = tokenize(title)
+            bt = tokenize(body)
+            title_len[di] = len(tt)
+            body_len[di] = len(bt)
+            tf_t: dict[str, int] = defaultdict(int)
+            tf_b: dict[str, int] = defaultdict(int)
+            for tok in tt:
+                tf_t[tok] += 1
+            for tok in bt:
+                tf_b[tok] += 1
+            for tok in set(tf_t) | set(tf_b):
+                batch_rows.append((tok, di, int(tf_t.get(tok, 0)), int(tf_b.get(tok, 0))))
+            law_id = str((d.get("law_id") or d.get("instrument_id") or [""])[i] or "")
+            instrument_id = str(
+                (d.get("instrument_id") or d.get("law_id") or [""])[i] or ""
+            )
+            meta_buf.append(
+                {
+                    "entry_cid": str(d["entry_cid"][i]),
+                    "document_index": di,
+                    "law_cid": str((d.get("law_cid") or [""])[i] or ""),
+                    "instrument_id": instrument_id,
+                    "law_id": law_id,
+                    "source_id": str(d["source_id"][i]),
+                    "title": title,
+                    "instrument_title": str(
+                        (d.get("instrument_title") or [""])[i] or ""
+                    ),
+                    "article_number": str((d.get("article_number") or [""])[i] or ""),
+                    "article_title": str((d.get("article_title") or [""])[i] or ""),
+                    "record_type": str(d["record_type"][i]),
+                    "language": str((d.get("language") or [""])[i] or ""),
+                    "jurisdiction": str((d.get("jurisdiction") or [""])[i] or ""),
+                }
+            )
+            if len(batch_rows) >= 20_000:
+                conn.executemany(
+                    "INSERT OR REPLACE INTO tf VALUES (?,?,?,?)", batch_rows
+                )
+                batch_rows.clear()
+        processed += m
+        if len(meta_buf) >= 20_000:
+            dfm = pd.DataFrame(meta_buf)
+            if meta_path.exists():
+                old = pd.read_parquet(meta_path)
+                dfm = pd.concat([old, dfm], ignore_index=True)
+                del old
+            dfm.to_parquet(meta_path, index=False)
+            del dfm
+            meta_buf.clear()
+            gc.collect()
+        if processed % 20_000 == 0:
+            checkpoint(f"bm25_tf_tokenize", row=processed, every_n=20_000, log=log)
+            gc.collect()
+    if batch_rows:
+        conn.executemany("INSERT OR REPLACE INTO tf VALUES (?,?,?,?)", batch_rows)
+        batch_rows.clear()
+    if meta_buf:
+        dfm = pd.DataFrame(meta_buf)
+        if meta_path.exists():
+            old = pd.read_parquet(meta_path)
+            dfm = pd.concat([old, dfm], ignore_index=True)
+            del old
+        dfm.to_parquet(meta_path, index=False)
+        del dfm
+        meta_buf.clear()
+    conn.commit()
+    if log:
+        log("bm25 tf spilled; writing documents")
+
+    doc_len = (title_len * TITLE_WEIGHT + body_len * BODY_WEIGHT).astype(np.float64)
+    avgdl = float(doc_len.mean()) if n_docs else 0.0
+    meta_df = pd.read_parquet(meta_path).sort_values("document_index").reset_index(drop=True)
+    assert len(meta_df) == n_docs
+    meta_df["title_length"] = title_len[meta_df["document_index"].to_numpy()]
+    meta_df["body_length"] = body_len[meta_df["document_index"].to_numpy()]
+    meta_df["document_length"] = np.round(
+        doc_len[meta_df["document_index"].to_numpy()]
+    ).astype(int)
+    meta_df["schema_version"] = SCHEMA_VERSION
+    meta_df.to_parquet(docs_path, index=False)
+    del meta_df
+    gc.collect()
+    meta_path.unlink(missing_ok=True)
+
+    posting_rows: list[dict] = []
+    n_postings = 0
+    n_terms = 0
+    part_i = 0
+    cur_term = None
+    cur_items: list = []
+
+    def flush_term(term: str, items: list) -> None:
+        nonlocal n_postings, n_terms, part_i, posting_rows
+        if not items:
+            return
+        n_terms += 1
+        dfreq = len(items)
+        cfreq = sum(int(ttf) + int(btf) for _, ttf, btf in items)
+        idf = _idf(n_docs, dfreq)
+        chunks = [
+            items[i : i + POSTING_ROWS_PER_RECORD]
+            for i in range(0, max(len(items), 1), POSTING_ROWS_PER_RECORD)
+        ]
+        n_chunks = len(chunks)
+        for cidx, chunk in enumerate(chunks):
+            posting_rows.append(
+                {
+                    "term": term,
+                    "document_indices": [int(d) for d, _, _ in chunk],
+                    "title_frequencies": [int(ttf) for _, ttf, _ in chunk],
+                    "body_frequencies": [int(btf) for _, _, btf in chunk],
+                    "tfs": [
+                        TITLE_WEIGHT * int(ttf) + BODY_WEIGHT * int(btf)
+                        for _, ttf, btf in chunk
+                    ],
+                    "lengths": [int(round(doc_len[int(d)])) for d, _, _ in chunk],
+                    "document_lengths": [
+                        int(round(doc_len[int(d)])) for d, _, _ in chunk
+                    ],
+                    "document_frequency": int(dfreq),
+                    "corpus_frequency": int(cfreq),
+                    "idf": float(idf),
+                    "posting_chunk_index": int(cidx),
+                    "posting_chunk_count": int(n_chunks),
+                    "schema_version": SCHEMA_VERSION,
+                }
+            )
+        n_postings += dfreq
+        if len(posting_rows) >= 8_000:
+            pd.DataFrame(posting_rows).to_parquet(
+                spill / f"postings_part_{part_i:08d}.parquet", index=False
+            )
+            posting_rows.clear()
+            part_i += 1
+            gc.collect()
+
+    for term, doc, ttf, btf in conn.execute(
+        "SELECT term, doc, ttf, btf FROM tf ORDER BY term, doc"
+    ):
+        term = str(term)
+        if cur_term is None:
+            cur_term = term
+        if term != cur_term:
+            flush_term(cur_term, cur_items)
+            cur_items = []
+            cur_term = term
+            if n_terms and n_terms % 50_000 == 0:
+                checkpoint(f"bm25_postings_terms", row=n_terms, every_n=50_000, log=log)
+        cur_items.append((int(doc), int(ttf), int(btf)))
+    if cur_term is not None:
+        flush_term(cur_term, cur_items)
+    if posting_rows:
+        pd.DataFrame(posting_rows).to_parquet(
+            spill / f"postings_part_{part_i:08d}.parquet", index=False
+        )
+        posting_rows.clear()
+    conn.close()
+    gc.collect()
+
+    parts = sorted(spill.glob("postings_part_*.parquet"))
+    frames: list[pd.DataFrame] = []
+    for i, part in enumerate(parts):
+        frames.append(pd.read_parquet(part))
+        if len(frames) >= 8:
+            frames = [pd.concat(frames, ignore_index=True)]
+            gc.collect()
+        if i and i % 20 == 0:
+            checkpoint(f"concat_postings", row=i, every_n=20, log=log)
+    postings = pd.concat(frames, ignore_index=True) if frames else pd.DataFrame()
+    del frames
+    for part in parts:
+        part.unlink()
+    postings.to_parquet(post_path, index=False)
+    out_rows = len(postings)
+    del postings
+    gc.collect()
+    stats = {
+        "k1": K1,
+        "b": B,
+        "title_weight": TITLE_WEIGHT,
+        "body_weight": BODY_WEIGHT,
+        "average_document_length": avgdl,
+        "tokenizer": "fts5-unicode61-remove-diacritics-2-python/v1",
+        "max_query_terms": 64,
+        "posting_rows_per_record": POSTING_ROWS_PER_RECORD,
+        "terms_per_shard": TERMS_PER_SHARD,
+        "n_docs": n_docs,
+        "n_terms": int(n_terms),
+        "n_posting_rows": int(out_rows),
+        "n_postings": int(n_postings),
+    }
+    spill_pickle(stats_path, stats)
+    try:
+        bm25_sql.unlink()
+    except Exception:
+        pass
+    if log:
+        log(f"bm25 spill done terms={n_terms} posting_rows={out_rows}")
+    return {"stats": stats, "documents": docs_path, "postings": post_path}
+
+
+def should_use_sqlite(n_docs: int, threshold: int = SQLITE_THRESHOLD) -> bool:
+    return n_docs >= threshold

country_laws_ir/tokenize.py

@@ -0,0 +1,21 @@
+"""FTS5 unicode61 remove_diacritics=2-style tokenizer."""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+_TOKEN_RE = re.compile(r"[0-9A-Za-z]+", re.UNICODE)
+
+
+def fold_diacritics(text: str) -> str:
+    if not text:
+        return ""
+    nfkd = unicodedata.normalize("NFKD", text)
+    return "".join(ch for ch in nfkd if not unicodedata.combining(ch)).lower()
+
+
+def tokenize(text: str | None) -> list[str]:
+    if not text:
+        return []
+    return _TOKEN_RE.findall(fold_diacritics(str(text)))

country_laws_ir/upload.py

@@ -0,0 +1,24 @@
+"""Hub upload is intentionally not implemented in this local pipeline.
+
+Later publish (operator machine, never from this run):
+
+    export HF_TOKEN=...   # never commit / never echo
+    hf upload-large-folder justicedao/ipfs_malta_laws_ir \\
+      /workspace/country-laws-ir/releases/ipfs_malta_laws_ir \\
+      --repo-type dataset --no-private --num-workers 8 \\
+      --exclude "**/__pycache__/**" --exclude "**/*.pyc"
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+def upload_release(local_dir: Path, repo_id: str) -> dict[str, Any]:
+    raise RuntimeError(
+        "Hub upload is disabled in the local country-laws-ir pipeline. "
+        "Publish later with: hf upload-large-folder "
+        f"{repo_id} {local_dir} --repo-type dataset --no-private --num-workers 8 "
+        '--exclude "**/__pycache__/**" --exclude "**/*.pyc"'
+    )

country_laws_ir/vectors.py

@@ -0,0 +1,335 @@
+"""thenlper/gte-small 384-d embeddings + centroid-sorted shards.
+
+If sentence-transformers/torch cannot embed, layout_stub_vectors() documents the
+expected schema so corpus/BM25/graph releases remain complete.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from . import MAX_ROWS_PER_FILE, SCHEMA_VERSION
+
+MODEL_NAME = "thenlper/gte-small"
+DIMENSION = 384
+MAX_ROWS_PER_CENTROID = 8192
+MAX_SHARDS_PER_CENTROID = 2
+
+
+def _l2_normalize(x: np.ndarray, eps: float = 1e-12) -> np.ndarray:
+    n = np.linalg.norm(x, axis=-1, keepdims=True)
+    return x / np.maximum(n, eps)
+
+
+def embeddings_available() -> bool:
+    try:
+        import torch  # noqa: F401
+        from sentence_transformers import SentenceTransformer  # noqa: F401
+
+        return True
+    except Exception:
+        return False
+
+
+def encode_corpus(
+    corpus: pd.DataFrame,
+    batch_size: int = 64,
+    device: str = "cpu",
+    checkpoint_path: str | None = None,
+    chunk_size: int = 4096,
+) -> np.ndarray:
+    """Encode corpus texts with gte-small in chunks; persist checkpoints when given."""
+    import json
+    import os
+    from datetime import datetime, timezone
+    from pathlib import Path as _Path
+
+    from sentence_transformers import SentenceTransformer
+
+    from .auth import configure_hf
+
+    configure_hf()
+    cache_root = _Path("/workspace/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 ""
+        body = getattr(rec, "body", "") or ""
+        sid = getattr(rec, "source_id", "") or getattr(rec, "instrument_id", "")
+        texts.append(f"{title}\n{body[:4000]}".strip() or title or sid)
+    n = len(texts)
+    out = np.zeros((n, DIMENSION), dtype=np.float32)
+    done = 0
+    ckpt = _Path(checkpoint_path) if checkpoint_path else None
+    meta_path = ckpt.with_suffix(".json") if ckpt else None
+    meta_n = None
+    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
+    if ckpt is not None and ckpt.exists():
+        cached = np.load(ckpt)
+        same_corpus = meta_n is None or int(meta_n) == n
+        if (
+            same_corpus
+            and cached.ndim == 2
+            and cached.shape[1] == DIMENSION
+            and 0 < cached.shape[0] <= n
+        ):
+            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
+    model = SentenceTransformer(MODEL_NAME, device=device)
+    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
+        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(),
+                        }
+                    )
+                    + "\n",
+                    encoding="utf-8",
+                )
+    return out
+
+
+def _spherical_kmeans(x: np.ndarray, k: int, iters: int = 12, seed: int = 0) -> np.ndarray:
+    rng = np.random.default_rng(seed)
+    n = len(x)
+    k = min(k, n)
+    centers = x[rng.choice(n, size=k, replace=False)].copy()
+    labels = np.zeros(n, dtype=np.int32)
+    for _ in range(iters):
+        sim = x @ centers.T
+        labels = sim.argmax(axis=1).astype(np.int32)
+        new = []
+        for j in range(k):
+            mask = labels == j
+            if not mask.any():
+                new.append(x[rng.integers(0, n)])
+            else:
+                new.append(_l2_normalize(x[mask].mean(axis=0)))
+        centers = np.stack(new).astype(np.float32)
+    return labels
+
+
+def _recursive_clusters(x: np.ndarray, max_size: int = MAX_ROWS_PER_FILE) -> list[np.ndarray]:
+    n = len(x)
+    idx = np.arange(n)
+    if n <= max_size:
+        return [idx]
+    labels = _spherical_kmeans(x, k=2)
+    clusters = []
+    for lab in (0, 1):
+        members = idx[labels == lab]
+        if len(members) == 0:
+            continue
+        if len(members) <= max_size:
+            clusters.append(members)
+        else:
+            sub = _recursive_clusters(x[members], max_size=max_size)
+            clusters.extend([members[s] for s in sub])
+    if not clusters:
+        mid = n // 2
+        return [idx[:mid], idx[mid:]]
+    return clusters
+
+
+def layout_vectors(corpus: pd.DataFrame, embeddings: np.ndarray) -> dict[str, Any]:
+    x = _l2_normalize(np.asarray(embeddings, dtype=np.float32))
+    clusters = _recursive_clusters(x, max_size=MAX_ROWS_PER_FILE)
+    vector_rows = []
+    chunk_meta = []
+    global_centroid = _l2_normalize(x.mean(axis=0))
+    for cluster_id, members in enumerate(clusters):
+        shard_centroid = _l2_normalize(x[members].mean(axis=0))
+        sims = x[members] @ shard_centroid
+        order = np.argsort(-sims)
+        members = members[order]
+        sims = sims[order]
+        chunk_id = f"vec-{cluster_id:06d}"
+        for local_i, doc_i in enumerate(members):
+            row = corpus.iloc[int(doc_i)]
+            vector_rows.append(
+                {
+                    "chunk_id": chunk_id,
+                    "cluster_id": int(cluster_id),
+                    "entry_cid": row["entry_cid"],
+                    "faiss_id": int(doc_i),
+                    "document_index": int(row["document_index"]),
+                    "corpus_chunk_id": int(row["document_index"] // MAX_ROWS_PER_FILE),
+                    "corpus_row_offset": int(row["document_index"] % MAX_ROWS_PER_FILE),
+                    "law_cid": row.get("law_cid", ""),
+                    "instrument_id": row.get("instrument_id", row.get("law_id", "")),
+                    "law_id": row.get("law_id", row.get("instrument_id", "")),
+                    "title": row.get("title", row.get("instrument_title", "")),
+                    "record_type": row["record_type"],
+                    "language": row.get("language", ""),
+                    "jurisdiction": row.get("jurisdiction", ""),
+                    "embedding": x[int(doc_i)].tolist(),
+                    "schema_version": SCHEMA_VERSION,
+                }
+            )
+        chunk_meta.append(
+            {
+                "cluster_id": int(cluster_id),
+                "chunk_id": chunk_id,
+                "centroid": shard_centroid.tolist(),
+                "shard_centroid": shard_centroid.tolist(),
+                "centroid_min_score": float(sims.min()) if len(sims) else 0.0,
+                "centroid_shard_count": 1,
+                "chunk_in_cluster": 0,
+                "dimension": DIMENSION,
+                "model_name": MODEL_NAME,
+                "row_count": int(len(members)),
+                "first_key": corpus.iloc[int(members[0])]["entry_cid"] if len(members) else "",
+                "last_key": corpus.iloc[int(members[-1])]["entry_cid"] if len(members) else "",
+            }
+        )
+    vectors_df = pd.DataFrame(vector_rows)
+    return {
+        "vectors": vectors_df,
+        "chunk_meta": chunk_meta,
+        "global_centroid": global_centroid.tolist(),
+        "stats": {
+            "model_name": MODEL_NAME,
+            "dimension": DIMENSION,
+            "similarity": "cosine",
+            "assignment": "recursive_spherical_kmeans",
+            "layout": "semantic_centroid_groups",
+            "rows_sorted_by": "cosine_similarity_to_shard_centroid_desc",
+            "max_rows_per_chunk": MAX_ROWS_PER_FILE,
+            "max_rows_per_centroid": MAX_ROWS_PER_CENTROID,
+            "max_shards_per_centroid": MAX_SHARDS_PER_CENTROID,
+            "default_probe_centroids": min(4, max(1, len(clusters))),
+            "centroid_count": len(clusters),
+            "shard_count": len(clusters),
+            "n_vectors": int(len(vectors_df)),
+            "status": "embedded",
+        },
+    }
+
+
+def layout_stub_vectors(corpus: pd.DataFrame, reason: str) -> dict[str, Any]:
+    """Document expected vector schema when embeddings cannot be produced."""
+    rows = []
+    for _, row in corpus.iterrows():
+        rows.append(
+            {
+                "chunk_id": "vec-stub-000000",
+                "cluster_id": 0,
+                "entry_cid": row["entry_cid"],
+                "faiss_id": int(row["document_index"]),
+                "document_index": int(row["document_index"]),
+                "corpus_chunk_id": int(row["document_index"] // MAX_ROWS_PER_FILE),
+                "corpus_row_offset": int(row["document_index"] % MAX_ROWS_PER_FILE),
+                "law_cid": row.get("law_cid", ""),
+                "instrument_id": row.get("instrument_id", ""),
+                "law_id": row.get("law_id", ""),
+                "title": row.get("title", ""),
+                "record_type": row["record_type"],
+                "language": row.get("language", ""),
+                "jurisdiction": row.get("jurisdiction", ""),
+                "embedding": None,
+                "schema_version": SCHEMA_VERSION,
+            }
+        )
+    vectors_df = pd.DataFrame(rows)
+    zero = [0.0] * DIMENSION
+    chunk_meta = [
+        {
+            "cluster_id": 0,
+            "chunk_id": "vec-stub-000000",
+            "centroid": zero,
+            "shard_centroid": zero,
+            "centroid_min_score": 0.0,
+            "centroid_shard_count": 1,
+            "chunk_in_cluster": 0,
+            "dimension": DIMENSION,
+            "model_name": MODEL_NAME,
+            "row_count": int(len(vectors_df)),
+            "first_key": vectors_df.iloc[0]["entry_cid"] if len(vectors_df) else "",
+            "last_key": vectors_df.iloc[-1]["entry_cid"] if len(vectors_df) else "",
+            "stub": True,
+            "stub_reason": reason,
+        }
+    ]
+    return {
+        "vectors": vectors_df,
+        "chunk_meta": chunk_meta,
+        "global_centroid": zero,
+        "stats": {
+            "model_name": MODEL_NAME,
+            "dimension": DIMENSION,
+            "similarity": "cosine",
+            "assignment": "stub",
+            "layout": "semantic_centroid_groups",
+            "rows_sorted_by": "document_index",
+            "max_rows_per_chunk": MAX_ROWS_PER_FILE,
+            "max_rows_per_centroid": MAX_ROWS_PER_CENTROID,
+            "max_shards_per_centroid": MAX_SHARDS_PER_CENTROID,
+            "default_probe_centroids": 1,
+            "centroid_count": 1 if len(vectors_df) else 0,
+            "shard_count": 1 if len(vectors_df) else 0,
+            "n_vectors": 0,
+            "status": "stub",
+            "stub_reason": reason,
+            "expected_columns": [
+                "entry_cid",
+                "document_index",
+                "embedding",
+                "law_cid",
+                "instrument_id",
+                "title",
+                "record_type",
+                "language",
+                "jurisdiction",
+            ],
+        },
+    }

data/bm25/postings/part-000000.parquet

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

data/graph/edges/part-000000.parquet

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

data/graph/edges/part-000007.parquet

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

data/graph/edges/part-000009.parquet

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

data/graph/edges/part-000014.parquet

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

data/graph/edges/part-000015.parquet

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

data/graph/edges/part-000016.parquet

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

data/graph/edges/part-000017.parquet

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

data/graph/edges/part-000020.parquet

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

data/graph/edges/part-000026.parquet

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

data/graph/edges/part-000028.parquet

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

data/graph/edges/part-000030.parquet

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

data/graph/edges/part-000031.parquet

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

data/graph/edges/part-000033.parquet

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

data/graph/edges/part-000036.parquet

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

data/graph/edges/part-000039.parquet

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

data/graph/edges/part-000040.parquet

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

data/graph/edges/part-000044.parquet

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

data/graph/edges/part-000045.parquet

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

data/graph/edges/part-000050.parquet

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

data/graph/edges/part-000051.parquet

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

data/graph/edges/part-000055.parquet

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

data/graph/edges/part-000056.parquet

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

data/graph/edges/part-000060.parquet

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

data/graph/edges/part-000069.parquet

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

manifest.json

@@ -0,0 +1,153 @@
+{
+  "schema_version": "country-laws-ir-graphrag/v1",
+  "dataset_revision": "b99006fea61b3c3adb01a85eeeee6374f5fe86a7",
+  "country": {
+    "slug": "kazakhstan",
+    "repo": "endomorphosis/ipfs_kazakhstan_laws",
+    "name": "Kazakhstan",
+    "indexable": true,
+    "skip_reason": null,
+    "local_source_dir": "/workspace/country-laws-ir/cache/kazakhstan_filtered_b99006fea61b",
+    "source_revision": "b99006fea61b3c3adb01a85eeeee6374f5fe86a7"
+  },
+  "source": {
+    "source_dataset": "endomorphosis/ipfs_kazakhstan_laws",
+    "source_revision": "b99006fea61b3c3adb01a85eeeee6374f5fe86a7",
+    "laws_path": "/workspace/country-laws-ir/cache/kazakhstan_filtered_b99006fea61b/data/laws.parquet",
+    "articles_path": "/workspace/country-laws-ir/cache/kazakhstan_filtered_b99006fea61b/data/articles.parquet",
+    "laws_sha256": null,
+    "articles_sha256": null,
+    "n_laws_source": 390,
+    "n_articles_source": 23665,
+    "laws_columns": [
+      "id",
+      "title",
+      "text",
+      "source_url",
+      "source_type",
+      "jurisdiction",
+      "country",
+      "language",
+      "eli",
+      "date",
+      "date_issued",
+      "retrieved_at",
+      "license",
+      "law_status",
+      "identifier",
+      "official_identifier",
+      "article_count",
+      "json_path",
+      "metadata_json"
+    ],
+    "articles_columns": [
+      "law_id",
+      "id",
+      "title",
+      "text",
+      "source_url",
+      "document_number",
+      "article_number",
+      "record_type",
+      "metadata_json"
+    ],
+    "local_source_dir": "/workspace/country-laws-ir/cache/kazakhstan_filtered_b99006fea61b",
+    "pack_meta": {
+      "slug": "kazakhstan",
+      "name": "Kazakhstan",
+      "repo": "endomorphosis/ipfs_kazakhstan_laws",
+      "source_dataset": "endomorphosis/ipfs_kazakhstan_laws",
+      "source_revision": "b99006fea61b3c3adb01a85eeeee6374f5fe86a7",
+      "filtered": true,
+      "filter_reason": "memsafe pass-through (chrome skipped; floor==hub; soft never-thin)",
+      "indexable": true,
+      "skip_reason": null,
+      "n_laws": 390,
+      "n_articles": 23665
+    }
+  },
+  "counts": {
+    "corpus_rows": 23665,
+    "laws": 0,
+    "articles": 23665,
+    "bm25_documents": 23665,
+    "bm25_posting_rows": 2437,
+    "graph_nodes": 24777,
+    "graph_edges": 300413,
+    "vector_rows": 23665,
+    "graph_incoming_adjacency_rows": 0,
+    "graph_outgoing_adjacency_rows": 0
+  },
+  "bm25": {
+    "k1": 1.2,
+    "b": 0.75,
+    "title_weight": 5.0,
+    "body_weight": 1.0,
+    "average_document_length": 24.824424255229243,
+    "tokenizer": "fts5-unicode61-remove-diacritics-2-python/v1",
+    "max_query_terms": 64,
+    "posting_rows_per_record": 4096,
+    "terms_per_shard": 4096,
+    "n_docs": 23665,
+    "n_terms": 2422,
+    "n_posting_rows": 2437,
+    "n_postings": 256469
+  },
+  "graph": {
+    "n_nodes": 24777,
+    "n_edges": 300413,
+    "n_doc_nodes": 24034,
+    "n_facet_nodes": 743,
+    "edge_types": [
+      "ARTICLE_OF",
+      "BM25_NEIGHBOR_OF",
+      "HAS_INSTRUMENT",
+      "HAS_JURISDICTION",
+      "HAS_LANGUAGE",
+      "HAS_SOURCE",
+      "HAS_STATUS",
+      "IDENTIFIED_BY",
+      "IDENTIFIED_BY_ELI"
+    ],
+    "adjacency": "empty_placeholder_oom_avoidance"
+  },
+  "vector": {
+    "model_name": "thenlper/gte-small",
+    "dimension": 384,
+    "similarity": "cosine",
+    "assignment": "sequential_shards",
+    "layout": "semantic_centroid_groups",
+    "rows_sorted_by": "cosine_similarity_to_shard_centroid_desc",
+    "max_rows_per_chunk": 4096,
+    "n_vectors": 23665,
+    "centroid_count": 6,
+    "shard_count": 6,
+    "status": "embedded",
+    "via": "layout_vectors_memsafe_sequential"
+  },
+  "normalization": {
+    "source_dataset": "endomorphosis/ipfs_kazakhstan_laws",
+    "source_revision": "b99006fea61b3c3adb01a85eeeee6374f5fe86a7",
+    "n_laws_in": 390,
+    "n_articles_in": 23665,
+    "unit": "article",
+    "drops": {
+      "empty_body": 0,
+      "missing_instrument": 0,
+      "duplicate_cid": 0
+    },
+    "n_out": 23665,
+    "n_dropped_total": 0,
+    "via": "kazakhstan_corpus_stream",
+    "record_type_breakdown": {
+      "article": 23665
+    },
+    "language_breakdown": {
+      "ru": 23665
+    },
+    "never_invented_legal_text": true
+  },
+  "neighbor_via": "sqlite_fts",
+  "built_utc": "2026-09-13T16:37:14.333722+00:00",
+  "via": "kazakhstan_package_stream_graph"
+}

scripts/build_country_laws_ir.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""CLI: build a country-laws IR release (local; does not 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 build_country  # noqa: E402
+from country_laws_ir.catalog import target_repo  # noqa: E402
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--source-repo", "--source", dest="source", default="endomorphosis/ipfs_malta_laws",
+                    help="Hub dataset id or country slug (default: Malta pilot)")
+    ap.add_argument("--out", default=None, help="Release output directory")
+    ap.add_argument("--device", default="cpu")
+    ap.add_argument("--neighbor-k", type=int, default=8)
+    ap.add_argument("--skip-vectors", action="store_true")
+    ap.add_argument("--upload", action="store_true", help="Opt-in Hub upload (default: off)")
+    args = ap.parse_args()
+    result = build_country(
+        args.source,
+        out=Path(args.out) if args.out else None,
+        upload=bool(args.upload),
+        device=args.device,
+        neighbor_k=args.neighbor_k,
+        skip_vectors=args.skip_vectors,
+    )
+    print(json.dumps({
+        "out": result["out"],
+        "target_hub_id": result.get("target_hub_id") or target_repo(result["country"]),
+        "counts": result["counts"],
+        "normalization": {
+            "n_laws_in": result["normalization"]["n_laws_in"],
+            "n_articles_in": result["normalization"]["n_articles_in"],
+            "n_out": result["normalization"]["n_out"],
+            "unit": result["normalization"]["unit"],
+            "drops": result["normalization"]["drops"],
+        },
+        "vector_blocker": result.get("vector_blocker"),
+        "schema_version": result.get("schema_version"),
+    }, indent=2, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/generate_country_laws_ir.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""Generation entrypoint copied into Hub dataset repos."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from country_laws_ir.__main__ import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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())

scripts/query_country_laws_hf.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+from country_laws_ir.query import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/query_country_laws_ir.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+"""CLI wrapper for country_laws_ir.query."""
+
+from __future__ import annotations
+
+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.query import main  # noqa: E402
+
+if __name__ == "__main__":
+    raise SystemExit(main())