Initial pakistan country-laws-ir-graphrag/v1 release

.gitattributes

@@ -1,60 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp filter=lfs diff=lfs merge=lfs -text
-# Video files - compressed
-*.mp4 filter=lfs diff=lfs merge=lfs -text
-*.webm filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,132 @@
+---
+license: other
+task_categories:
+- text-retrieval
+tags:
+- legal
+- law
+- graphrag
+- bm25
+- research
+- not-legal-advice
+- pakistan
+pretty_name: Pakistan 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
+---
+
+# Pakistan legislation IR (CID-keyed sparse GraphRAG)
+
+Research retrieval release of `endomorphosis/ipfs_pakistan_laws` (revision `1455aac2978239f7047f06cf5755b217b315b158`) packaged as
+`country-laws-ir-graphrag/v1` (layout family `skillcenter-huggingface-release/v3` / publicus-ir).
+
+**Not legal advice.** This is a research snapshot. The official gazette /
+authentic source of Pakistan 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): `justicedao/ipfs_pakistan_laws_ir`.
+
+## Counts
+
+| Field | Value |
+| --- | --- |
+| Laws (corpus units) | 0 |
+| Articles (corpus units) | 4189 |
+| Canonical docs | 4189 |
+| BM25 terms | 28374 |
+| BM25 postings | 897615 |
+| Graph nodes | 5171 |
+| Graph edges | 40442 |
+| Vectors | 4189 × 384-d `thenlper/gte-small` (embedded) |
+
+## 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 justicedao/ipfs_pakistan_laws_ir . \
+  --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 `endomorphosis/ipfs_pakistan_laws`. CIDs identify local content; they do not prove public IPFS pinning.

build.py

@@ -0,0 +1,171 @@
+"""End-to-end build: normalize → BM25 → graph → vectors → package (no upload by default)."""
+
+from __future__ import annotations
+
+import json
+import traceback
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .bm25 import bm25_neighbors, build_index
+from .catalog import get_country, indexable_countries, target_repo
+from .graph import build_graph
+from .normalize import build_corpus, load_source
+from .package import package_release
+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"
+    _log(f"build start {repo} -> {out} (upload={upload})")
+    configure_hf()
+    CACHE.mkdir(parents=True, exist_ok=True)
+    REPORTS.mkdir(parents=True, exist_ok=True)
+    laws, articles, source_meta = load_source(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")
+
+    bm25 = build_index(corpus)
+    _log(f"bm25 terms={bm25['stats']['n_terms']} postings={bm25['stats']['n_postings']}")
+    _log(f"bm25 neighbors start n={len(corpus)} k={neighbor_k}")
+    neighbors = bm25_neighbors(bm25, k=neighbor_k)
+    _log("bm25 neighbors done")
+    graph = build_graph(corpus, neighbors)
+    _log(f"graph nodes={graph['stats']['n_nodes']} edges={graph['stats']['n_edges']}")
+
+    vector_blocker = None
+    if skip_vectors:
+        vectors = layout_stub_vectors(corpus, reason="skip_vectors flag")
+        vector_blocker = "skip_vectors"
+    elif embeddings_available():
+        try:
+            ckpt = CACHE / "embeddings" / f"{country['slug']}.npy"
+            _log(f"vectors encode start n={len(corpus)} 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']}")
+        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)
+    else:
+        vector_blocker = "sentence-transformers/torch unavailable"
+        _log(f"vectors stub: {vector_blocker}")
+        vectors = layout_stub_vectors(corpus, reason=vector_blocker)
+
+    code_root = Path(__file__).resolve().parent.parent
+    manifest = package_release(
+        out,
+        corpus,
+        bm25,
+        graph,
+        vectors,
+        source_meta,
+        country,
+        code_root,
+        normalization_report=norm_report,
+    )
+    _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,
+        "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/__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,171 @@
+"""End-to-end build: normalize → BM25 → graph → vectors → package (no upload by default)."""
+
+from __future__ import annotations
+
+import json
+import traceback
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from .bm25 import bm25_neighbors, build_index
+from .catalog import get_country, indexable_countries, target_repo
+from .graph import build_graph
+from .normalize import build_corpus, load_source
+from .package import package_release
+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"
+    _log(f"build start {repo} -> {out} (upload={upload})")
+    configure_hf()
+    CACHE.mkdir(parents=True, exist_ok=True)
+    REPORTS.mkdir(parents=True, exist_ok=True)
+    laws, articles, source_meta = load_source(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")
+
+    bm25 = build_index(corpus)
+    _log(f"bm25 terms={bm25['stats']['n_terms']} postings={bm25['stats']['n_postings']}")
+    _log(f"bm25 neighbors start n={len(corpus)} k={neighbor_k}")
+    neighbors = bm25_neighbors(bm25, k=neighbor_k)
+    _log("bm25 neighbors done")
+    graph = build_graph(corpus, neighbors)
+    _log(f"graph nodes={graph['stats']['n_nodes']} edges={graph['stats']['n_edges']}")
+
+    vector_blocker = None
+    if skip_vectors:
+        vectors = layout_stub_vectors(corpus, reason="skip_vectors flag")
+        vector_blocker = "skip_vectors"
+    elif embeddings_available():
+        try:
+            ckpt = CACHE / "embeddings" / f"{country['slug']}.npy"
+            _log(f"vectors encode start n={len(corpus)} 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']}")
+        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)
+    else:
+        vector_blocker = "sentence-transformers/torch unavailable"
+        _log(f"vectors stub: {vector_blocker}")
+        vectors = layout_stub_vectors(corpus, reason=vector_blocker)
+
+    code_root = Path(__file__).resolve().parent.parent
+    manifest = package_release(
+        out,
+        corpus,
+        bm25,
+        graph,
+        vectors,
+        source_meta,
+        country,
+        code_root,
+        normalization_report=norm_report,
+    )
+    _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,
+        "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,135 @@
+"""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": "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": "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": "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},
+]
+
+
+def get_country(source: str) -> dict[str, Any]:
+    source = source.strip()
+    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/normalize.py

@@ -0,0 +1,514 @@
+"""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 load_source(repo_id: str, cache_dir: Path) -> tuple[pd.DataFrame, pd.DataFrame, dict[str, Any]]:
+    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,530 @@
+"""Write country-laws-ir-graphrag/v1 thin-client layout (SkillCenter / publicus-ir family)."""
+
+from __future__ import annotations
+
+import json
+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")

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/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,327 @@
+"""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)
+        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/documents/part-000000.parquet

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

data/bm25/documents/part-000001.parquet

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

data/bm25/postings/part-000000.parquet

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

data/bm25/postings/part-000001.parquet

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

data/bm25/postings/part-000002.parquet

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

data/bm25/postings/part-000003.parquet

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

data/bm25/postings/part-000004.parquet

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

data/bm25/postings/part-000005.parquet

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

data/bm25/postings/part-000006.parquet

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

data/corpus/part-000000.parquet

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

data/corpus/part-000001.parquet

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

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

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

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

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

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

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

data/graph/edges/part-000000.parquet

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

data/graph/edges/part-000001.parquet

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

data/graph/edges/part-000002.parquet

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

data/graph/edges/part-000003.parquet

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

data/graph/edges/part-000004.parquet

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

data/graph/edges/part-000005.parquet

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

data/graph/edges/part-000006.parquet

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

data/graph/edges/part-000007.parquet

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

data/graph/edges/part-000008.parquet

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

data/graph/edges/part-000009.parquet

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

data/graph/nodes/part-000000.parquet

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

data/graph/nodes/part-000001.parquet

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

data/vectors/part-000000.parquet

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

data/vectors/part-000001.parquet

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

indexes/bm25_document_chunks.parquet

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

indexes/bm25_keyword_shards.parquet

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

indexes/corpus_chunks.parquet

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