Incremental country-laws-ir GraphRAG release for justicedao/ipfs_libya_laws_ir

README.md

@@ -11,6 +11,8 @@ tags:
 - not-legal-advice
 - libya
 pretty_name: Libya laws IR (CID-keyed GraphRAG)
+size_categories:
+- n<1K
 configs:
 - config_name: corpus
   data_files:
@@ -47,11 +49,14 @@ configs:
 - config_name: graph_outgoing_adjacency
   data_files:
   - split: train
-    path: data/graph/adjacency/outgoing/*.parquet
+    path: data/graph/adjacency/out/*.parquet
 - config_name: graph_incoming_adjacency
   data_files:
   - split: train
-    path: data/graph/adjacency/incoming/*.parquet
+    path: data/graph/adjacency/in/*.parquet
+language:
+- ar
+- en
 ---
 
 # Libya legislation IR (CID-keyed sparse GraphRAG)
@@ -72,14 +77,14 @@ Target Hub id (packaging metadata only): `justicedao/ipfs_libya_laws_ir`.
 
 | Field | Value |
 | --- | --- |
-| Laws (corpus units) | 0 |
+| Laws (corpus units) | 69 |
 | Articles (corpus units) | 689 |
-| Canonical docs | 689 |
-| BM25 terms | 739 |
-| BM25 postings | 4645 |
-| Graph nodes | 822 |
-| Graph edges | 4823 |
-| Vectors | 689 × 384-d `thenlper/gte-small` (embedded) |
+| Canonical docs | 758 |
+| BM25 terms | 15202 |
+| BM25 postings | 33741 |
+| Graph nodes | 975 |
+| Graph edges | 5306 |
+| Vectors | 758 × 384-d `thenlper/gte-small` (embedded) |
 
 ## Canonical fields
 

country_laws_ir/__main__.py

@@ -83,6 +83,21 @@ def main(argv: list[str] | None = None) -> int:
     p_ver.add_argument("--all", action="store_true", help="Verify every indexable catalog country")
     p_ver.add_argument("--limit", type=int, default=None)
 
+    p_loop = sub.add_parser(
+        "normalize-loop",
+        help="scan residuals, improve the normalizer script with llm_router, or apply that script",
+    )
+    p_loop.add_argument("stage", choices=["scan", "improve", "apply", "run"])
+    p_loop.add_argument("--cache", default=None)
+    p_loop.add_argument("--out", default=None)
+    p_loop.add_argument("--reports", default=None, help="Per-country residual JSON directory")
+    p_loop.add_argument("--slug", default=None, help="One country, for a subprocess")
+    p_loop.add_argument("--workers", type=int, default=None, help="Country processes (default: one per CPU)")
+    p_loop.add_argument("--limit", type=int, default=None)
+    p_loop.add_argument("--passes", type=int, default=40, help="Improve batches sent to llm_router")
+    p_loop.add_argument("--force", action="store_true", help="Redo finished countries and retry unresolved lines")
+    p_loop.add_argument("--progress", default=None, help="JSONL file appended as each country or improve pass finishes")
+
     p_raw = sub.add_parser("package-raw")
     p_raw.add_argument("--slug", required=True, help="Country slug used in justicedao/ipfs_<slug>_laws_ir")
     p_raw.add_argument("--instruments-dir", default=None,
@@ -253,6 +268,125 @@ def main(argv: list[str] | None = None) -> int:
             )
         )
         return 1 if failed else 0
+    if args.cmd == "normalize-loop":
+        from .build import CACHE, ROOT
+        from .normalize_loop import (
+            _apply_job,
+            _scan_job,
+            append_progress,
+            apply_done,
+            cache_packs,
+            improve_from_reports,
+            load_generate_text,
+            run_parallel,
+            scan_done,
+            worker_count,
+        )
+
+        cache = Path(args.cache) if args.cache else CACHE
+        reports = Path(args.reports) if args.reports else ROOT / "reports" / "residuals"
+        out = Path(args.out) if args.out else ROOT / "llm-normalized"
+        packs = cache_packs(cache, slug=args.slug)
+        if args.limit:
+            packs = packs[: int(args.limit)]
+        workers = worker_count(args.workers)
+        progress = Path(args.progress) if args.progress else ROOT / "reports" / f"normalize_{args.stage}.jsonl"
+
+        def _pending(stage: str) -> tuple[list[tuple[str, str, str]], list[str]]:
+            jobs: list[tuple[str, str, str]] = []
+            skipped: list[str] = []
+            for slug, path in packs:
+                done = scan_done(reports, slug) if stage == "scan" else apply_done(out, slug)
+                if done and not args.force:
+                    skipped.append(slug)
+                    continue
+                dest = reports if stage == "scan" else out
+                jobs.append((slug, str(path), str(dest)))
+            return jobs, skipped
+
+        def _run(stage: str, worker) -> list[dict]:
+            jobs, skipped = _pending(stage)
+            total = len(jobs) + len(skipped)
+            done = len(skipped)
+            print(json.dumps({
+                "event": "start",
+                "stage": stage,
+                "workers": workers,
+                "done": done,
+                "pending": len(jobs),
+                "total": total,
+                "progress": str(progress),
+            }), flush=True)
+            state = {"done": done}
+
+            def _on_done(row: dict) -> None:
+                state["done"] += 1
+                print(json.dumps({
+                    "event": stage,
+                    "done": state["done"],
+                    "total": total,
+                    **row,
+                }), flush=True)
+
+            return run_parallel(jobs, worker, workers, progress_path=progress, on_done=_on_done)
+
+        if args.stage == "scan":
+            rows = _run("scan", _scan_job)
+            failed = [row for row in rows if row.get("error")]
+            print(json.dumps({"stage": "scan", "workers": workers, "n": len(rows), "n_failed": len(failed)}, indent=2))
+            return 1 if failed else 0
+        if args.stage == "apply":
+            rows = _run("apply", _apply_job)
+            failed = [row for row in rows if row.get("error")]
+            print(json.dumps({"stage": "apply", "workers": workers, "n": len(rows), "n_failed": len(failed)}, indent=2))
+            return 1 if failed else 0
+        def _on_pass(row: dict) -> None:
+            print(json.dumps({"event": "improve", **row}, ensure_ascii=False), flush=True)
+            append_progress(progress, {"event": "improve", **row})
+
+        def _improve():
+            print(json.dumps({
+                "event": "start",
+                "stage": "improve",
+                "passes": args.passes,
+                "reports": str(reports),
+            }), flush=True)
+            try:
+                generate = load_generate_text()
+            except Exception as exc:
+                print(json.dumps({"error": f"llm_router unavailable: {exc}"}), flush=True)
+                return None
+            return improve_from_reports(
+                reports,
+                generate,
+                max_passes=args.passes,
+                on_pass=_on_pass,
+                reset_unresolved=bool(args.force),
+            )
+
+        if args.stage == "improve":
+            result = _improve()
+            if result is None:
+                return 1
+            print(json.dumps({"stage": "improve", **result}, indent=2, ensure_ascii=False))
+            return 0
+        # run scans, then improves the script. Applying the script to every
+        # pack is the separate ``apply`` stage.
+        scan_rows = _run("scan", _scan_job)
+        failed = [row for row in scan_rows if row.get("error")]
+        if failed:
+            print(json.dumps({"stage": "run", "n_scanned": len(scan_rows), "n_failed": len(failed)}, indent=2))
+            return 1
+        improved = _improve()
+        if improved is None:
+            return 1
+        print(json.dumps(
+            {"stage": "run", "workers": workers, "improve": improved, "n_scanned": len(scan_rows)},
+            indent=2,
+            ensure_ascii=False,
+            default=str,
+        ))
+        return 0
     if args.cmd == "package-raw":
         from .build import RELEASES
         from .raw_package import default_instruments_dir, package_instruments

country_laws_ir/citations.py

@@ -0,0 +1,139 @@
+"""Official and Bluebook citations for country-law corpus rows.
+
+Bluebook T2/T10 abbreviations are used only when this table has a row.
+Unknown jurisdictions get ``official_citation`` only — never a invented
+Bluebook form. Query keys are normalized so ``ORS 1.010`` and
+``Or. Rev. Stat. § 1.010`` can hit the same row later.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+import unicodedata
+from typing import Any
+
+from pathlib import Path
+import json as _json
+
+_TABLE_PATH = Path(__file__).resolve().parent / "data" / "bluebook_t2.json"
+
+
+def _load_t2() -> dict[str, dict[str, Any]]:
+    if not _TABLE_PATH.is_file():
+        return {}
+    payload = _json.loads(_TABLE_PATH.read_text(encoding="utf-8"))
+    return payload if isinstance(payload, dict) else {}
+
+
+_BLUEBOOK_T2 = _load_t2()
+
+
+@dataclass(frozen=True)
+class Citation:
+    official_citation: str
+    bluebook_citation: str
+    cite_key: str
+    citation_status: str  # bluebook | official_only | unknown
+    pinpoint: str
+
+
+def normalize_cite_key(value: str) -> str:
+    if not value:
+        return ""
+    text = unicodedata.normalize("NFKC", value).lower()
+    text = text.replace("§", " s ")
+    text = text.replace("¶", " ")
+    text = re.sub(r"\bart(?:icle|\.)?\b", "art", text)
+    text = re.sub(r"\bsec(?:tion|\.)?\b", "s", text)
+    text = re.sub(r"[^a-z0-9]+", " ", text)
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def _pinpoint(article_number: str, section_number: str, record_type: str) -> str:
+    if record_type == "section" and section_number:
+        return f"§ {section_number}"
+    if article_number:
+        return f"art. {article_number}"
+    if section_number:
+        return f"§ {section_number}"
+    return ""
+
+
+def _t2_row(jurisdiction: str, country: str, slug: str = "") -> dict[str, Any]:
+    for key in (slug, country, jurisdiction):
+        hit = _BLUEBOOK_T2.get(str(key or "").strip().lower().replace("_", " "))
+        if isinstance(hit, dict):
+            return hit
+    return {}
+
+
+def assign_citation(
+    *,
+    eli: str = "",
+    official_identifier: str = "",
+    identifier: str = "",
+    instrument_title: str = "",
+    article_number: str = "",
+    section_number: str = "",
+    record_type: str = "law",
+    jurisdiction: str = "",
+    country: str = "",
+    slug: str = "",
+    year: str = "",
+) -> Citation:
+    pinpoint = _pinpoint(article_number, section_number, record_type)
+    official = (
+        (eli or "").strip()
+        or (official_identifier or "").strip()
+        or (identifier or "").strip()
+        or (instrument_title or "").strip()
+    )
+    if official and pinpoint and pinpoint.lower() not in official.lower():
+        official_cite = f"{official}, {pinpoint}"
+    else:
+        official_cite = official
+
+    t2 = _t2_row(jurisdiction, country, slug)
+    abbrev = str(t2.get("abbrev") or "")
+    emit = str(t2.get("emit") or "official_only")
+    required = list(t2.get("required") or [])
+    have = {
+        "year": bool(year),
+        "section": bool(section_number or (record_type == "section" and article_number)),
+        "article": bool(article_number),
+        "title": bool(instrument_title),
+    }
+    missing = [k for k in required if not have.get(k)]
+    bluebook = ""
+    if emit == "bluebook" and abbrev and not missing:
+        if pinpoint:
+            bluebook = f"{abbrev} {pinpoint}" + (f" ({year})" if year else "")
+        elif have.get("section"):
+            bluebook = f"{abbrev} § {section_number}" + (f" ({year})" if year else "")
+
+    if bluebook:
+        status = "bluebook"
+    elif official_cite:
+        status = "official_only"
+    else:
+        status = "unknown"
+
+    key_src = bluebook or official_cite
+    return Citation(
+        official_citation=official_cite,
+        bluebook_citation=bluebook,
+        cite_key=normalize_cite_key(key_src),
+        citation_status=status,
+        pinpoint=pinpoint,
+    )
+
+
+def citation_fields(cite: Citation) -> dict[str, Any]:
+    return {
+        "official_citation": cite.official_citation,
+        "bluebook_citation": cite.bluebook_citation,
+        "cite_key": cite.cite_key,
+        "citation_status": cite.citation_status,
+        "pinpoint": cite.pinpoint,
+    }

country_laws_ir/data/bluebook_t2.json

@@ -0,0 +1,27 @@
+{
+  "usa": {"abbrev": "U.S.C.", "emit": "bluebook", "required": ["title", "section"]},
+  "united states": {"abbrev": "U.S.C.", "emit": "bluebook", "required": ["title", "section"]},
+  "uk": {"abbrev": "U.K.", "emit": "official_only", "required": []},
+  "united kingdom": {"abbrev": "U.K.", "emit": "official_only", "required": []},
+  "australia": {"abbrev": "Cth", "emit": "official_only", "required": ["year"]},
+  "canada": {"abbrev": "S.C.", "emit": "official_only", "required": ["year"]},
+  "germany": {"abbrev": "BGBl.", "emit": "official_only", "required": []},
+  "france": {"abbrev": "J.O.", "emit": "official_only", "required": []},
+  "malta": {"abbrev": "Laws of Malta", "emit": "official_only", "required": []},
+  "ireland": {"abbrev": "Ir.", "emit": "official_only", "required": []},
+  "newzealand": {"abbrev": "N.Z.", "emit": "official_only", "required": []},
+  "new zealand": {"abbrev": "N.Z.", "emit": "official_only", "required": []},
+  "southafrica": {"abbrev": "S. Afr.", "emit": "official_only", "required": []},
+  "south africa": {"abbrev": "S. Afr.", "emit": "official_only", "required": []},
+  "india": {"abbrev": "India", "emit": "official_only", "required": []},
+  "japan": {"abbrev": "Japan", "emit": "official_only", "required": []},
+  "china": {"abbrev": "P.R.C.", "emit": "official_only", "required": []},
+  "netherlands": {"abbrev": "Stb.", "emit": "official_only", "required": []},
+  "austria": {"abbrev": "BGBl.", "emit": "official_only", "required": []},
+  "switzerland": {"abbrev": "AS", "emit": "official_only", "required": []},
+  "sweden": {"abbrev": "SFS", "emit": "official_only", "required": []},
+  "norway": {"abbrev": "Norsk Lovtidend", "emit": "official_only", "required": []},
+  "denmark": {"abbrev": "Lovtidende", "emit": "official_only", "required": []},
+  "finland": {"abbrev": "Finlex", "emit": "official_only", "required": []},
+  "eu": {"abbrev": "O.J.", "emit": "official_only", "required": []}
+}

country_laws_ir/data/learned_line_patterns.json

@@ -0,0 +1,3 @@
+{
+  "patterns": []
+}

country_laws_ir/duckdb_store.py

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

country_laws_ir/graph.py

@@ -68,7 +68,7 @@ def build_graph(
             "node_cid": law_cid,
             "node_type": "law",
             "entry_cid": "",
-            "label": getattr(rec, "instrument_title", None) or instrument_id,
+            "label": str(getattr(rec, "instrument_title", None) or instrument_id).replace("\x00", ""),
             "properties_json": _json(
                 {
                     "instrument_id": instrument_id,
@@ -92,7 +92,7 @@ def build_graph(
                 "node_cid": rec.entry_cid,
                 "node_type": node_type,
                 "entry_cid": rec.entry_cid,
-                "label": title,
+                "label": str(title or "").replace("\x00", ""),
                 "properties_json": _props_tuple(rec),
                 "schema_version": SCHEMA_VERSION,
             }
@@ -112,7 +112,7 @@ def build_graph(
                         "node_cid": fc,
                         "node_type": f"facet_{kind}",
                         "entry_cid": "",
-                        "label": f"{kind}:{value}",
+                        "label": f"{kind}:{value}".replace("\x00", ""),
                         "properties_json": _json({"kind": kind, "value": value}),
                         "schema_version": SCHEMA_VERSION,
                     }
@@ -157,7 +157,7 @@ def build_graph(
 
         law_cid = str(row_map.get("law_cid") or "")
         instrument_id = str(row_map.get("instrument_id") or "")
-        if rec.record_type == "article":
+        if rec.record_type in {"article", "section"}:
             parent = entry_by_instrument.get(instrument_id) or law_cid
             if parent and parent != rec.entry_cid:
                 edges.append(

country_laws_ir/normalize.py

@@ -24,6 +24,12 @@ from . import ENTRY_IDENTITY_SCHEMA, LAW_IDENTITY_SCHEMA, SCHEMA_VERSION
 from .auth import configure_hf, public_token
 from .cidutil import cid_of_json, sha256_file, sha256_hex
 from .schema import SchemaError, validate_articles, validate_laws
+from .reconstruct import (
+    article_sort_key,
+    parent_needs_reconstruct,
+    reconstruct_on,
+    reconstruct_parent,
+)
 from .structure import normalize_legal_text, split_structured_units
 
 COLLECTOR_DEFAULT = "endomorphosis/ipfs_datasets_py"
@@ -399,6 +405,34 @@ def _base_record(
     }
     if extra:
         rec.update(extra)
+    from .citations import assign_citation, citation_fields
+
+    slug = ""
+    if source_dataset.startswith("endomorphosis/ipfs_") and source_dataset.endswith("_laws"):
+        slug = source_dataset.split("ipfs_", 1)[1].removesuffix("_laws")
+    year = ""
+    if snapshot_date and len(snapshot_date) >= 4 and snapshot_date[:4].isdigit():
+        year = snapshot_date[:4]
+    extra = extra or {}
+    rec.update(
+        citation_fields(
+            assign_citation(
+                eli=str(rec.get("eli") or extra.get("eli") or ""),
+                official_identifier=str(
+                    rec.get("official_identifier") or extra.get("official_identifier") or ""
+                ),
+                identifier=str(rec.get("identifier") or extra.get("identifier") or ""),
+                instrument_title=instrument_title,
+                article_number=article_number,
+                section_number=str(extra.get("section_number") or ""),
+                record_type=record_type,
+                jurisdiction=jurisdiction,
+                country=str(extra.get("country") or ""),
+                slug=slug,
+                year=year,
+            )
+        )
+    )
     rec["entry_cid"] = _entry_cid(rec)
     rec["title_length"] = len(title_for_bm25)
     rec["body_length"] = len(body)
@@ -455,16 +489,137 @@ def build_corpus(
         "schema_surprises": list(source_meta.get("schema_surprises") or []),
         "n_out": 0,
         "never_invented_legal_text": True,
+        "n_reconstructed_parents": 0,
+        "n_reconstructed_truncated": 0,
+        "n_reconstructed_stubs": 0,
+        "n_empty_parents_with_articles_not_reconstructed": 0,
     }
 
     entries: list[dict[str, Any]] = []
+    slug = ""
+    if source_dataset.startswith("endomorphosis/ipfs_") and source_dataset.endswith("_laws"):
+        slug = source_dataset.split("ipfs_", 1)[1].removesuffix("_laws")
+
+    children_by_law: dict[str, list[dict[str, Any]]] = {}
+    if not articles_empty:
+        for _, row in articles.iterrows():
+            lid = _row_get(row, "law_id")
+            if not lid:
+                continue
+            children_by_law.setdefault(lid, []).append(
+                {
+                    "id": _row_get(row, "id"),
+                    "title": _row_get(row, "title"),
+                    "article_number": _row_get(row, "article_number"),
+                    "body": _row_get(row, "text"),
+                    "row": row,
+                }
+            )
+
+    reconstructed_ids: set[str] = set()
+    running_extra_bytes = 0
+
+    def _append_law_row(
+        instrument_id: str,
+        parent: dict[str, Any],
+        recon=None,
+    ) -> None:
+        body = parent["body"]
+        recon_extra: dict[str, Any] = {}
+        coverage = _coverage_from(
+            parent["row"],
+            parent["metadata"],
+            articles_empty=articles_empty,
+            sparse_fallback=sparse_fallback,
+        )
+        if recon is not None and recon.reconstructed_from_articles:
+            body = recon.body
+            recon_extra = recon.extra_fields()
+            coverage = f"{coverage}; reconstructed_from_articles"
+        if not body:
+            kids = children_by_law.get(instrument_id) or []
+            if kids:
+                report["n_empty_parents_with_articles_not_reconstructed"] += 1
+            report["drops"]["empty_body"] += 1
+            if len(report["drop_samples"]["empty_body"]) < 20:
+                report["drop_samples"]["empty_body"].append(instrument_id)
+            return
+        meta = parent["metadata"]
+        entries.append(
+            _base_record(
+                record_type="law",
+                source_dataset=source_dataset,
+                source_revision=source_revision,
+                instrument_id=instrument_id,
+                instrument_title=parent["instrument_title"],
+                law_cid=parent["law_cid"],
+                article_number="",
+                article_title="",
+                body=body,
+                jurisdiction=parent["jurisdiction"],
+                language=parent["language"],
+                source_url=parent["source_url"],
+                snapshot_date=_snapshot_date(parent["row"], meta, source_meta),
+                coverage=coverage,
+                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": "",
+                    "reconstructed_from_articles": False,
+                    **_hierarchy_fields(
+                        parent["instrument_title"], body, "", language=parent["language"]
+                    ),
+                    **recon_extra,
+                },
+            )
+        )
 
     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 instrument_id, parent in law_map.items():
+        kids = children_by_law.get(instrument_id) or []
+        recon = None
+        if reconstruct_on() and parent_needs_reconstruct(parent["body"], len(kids)):
+            recon = reconstruct_parent(
+                slug=slug,
+                parent_body=parent["body"],
+                parent_title=parent["instrument_title"],
+                children=[
+                    {
+                        "id": k["id"],
+                        "title": k["title"],
+                        "article_number": k["article_number"],
+                        "body": k["body"],
+                    }
+                    for k in kids
+                ],
+                running_extra_bytes=running_extra_bytes,
+                sha256_hex=sha256_hex,
+            )
+            running_extra_bytes += recon.extra_bytes
+            reconstructed_ids.add(instrument_id)
+            report["n_reconstructed_parents"] += 1
+            if recon.reconstruction_truncated:
+                report["n_reconstructed_truncated"] += 1
+            if recon.is_stub:
+                report["n_reconstructed_stubs"] += 1
+        _append_law_row(instrument_id, parent, recon)
+
+    emit_articles = use_articles or bool(reconstructed_ids)
+    skip_body_split = emit_articles
+
+    if emit_articles:
         for _, row in articles.iterrows():
             source_id = _row_get(row, "id")
             instrument_id = _row_get(row, "law_id")
@@ -521,13 +676,10 @@ def build_corpus(
                     },
                 )
             )
-    else:
+    elif not skip_body_split:
         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"]
             units = split_structured_units(body, language=parent["language"])
@@ -572,49 +724,11 @@ def build_corpus(
                             },
                         )
                     )
-                continue
-            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": "",
-                        **_hierarchy_fields(
-                            parent["instrument_title"], body, "", language=parent["language"]
-                        ),
-                    },
-                )
-            )
 
     entries.sort(
         key=lambda r: (
             r["instrument_id"],
-            r.get("article_number") or "",
-            r["source_id"],
+            article_sort_key(r.get("article_number") or "", r["source_id"]),
         )
     )
     n_before = len(entries)
@@ -639,6 +753,20 @@ def build_corpus(
         raise SchemaError("Duplicate entry_cid remained after dedupe")
     report["n_before_dedupe"] = n_before
     report["n_out"] = int(len(df))
+    if not df.empty and "record_type" in df.columns:
+        n_law_rows = int((df["record_type"] == "law").sum())
+        n_child_rows = int(df["record_type"].isin(["article", "section"]).sum())
+        report["n_law_rows"] = n_law_rows
+        report["n_child_rows"] = n_child_rows
+        report["n_instruments"] = int(df["instrument_id"].nunique()) if "instrument_id" in df.columns else n_law_rows
+        if n_law_rows and n_child_rows:
+            report["unit"] = (
+                "law+structured" if report.get("unit") == "structured" else "law+article"
+            )
+        elif n_law_rows:
+            report["unit"] = "law"
+        elif n_child_rows:
+            report["unit"] = "article"
     report["n_dropped_total"] = (
         report["drops"]["empty_body"]
         + report["drops"]["missing_instrument"]

country_laws_ir/normalize_loop.py

@@ -0,0 +1,608 @@
+"""Improve the row normalizer, then let that script normalize every row.
+
+``scan`` and ``apply`` only call ``normalize_legal_text``. They do not import
+the LLM router, so one subprocess per country does not boot a model.
+
+``improve`` imports ``llm_router`` once. Each pass sends a short batch of
+lines the current script still leaves in place. The model proposes whole-line
+patterns. A pattern is stored only when it matches one of those lines, misses
+every held-out legal sentence, and the script then actually drops the line.
+Accepted patterns live in ``data/learned_line_patterns.json`` and are applied
+by the same script that normalizes the rows. The model never rewrites a row.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+from collections import Counter
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from pathlib import Path
+from typing import Any, Callable, Sequence
+
+from .catalog import EXCLUDED_SLUGS
+from .structure import learned_patterns_path, normalize_legal_text
+
+GenerateText = Callable[[str], str]
+
+# Sentences the learned rules must not delete. Whole-line patterns that
+# full-match any of these are discarded.
+KEEP_LINES = (
+    "Article 1 The present Act applies throughout the territory and binds every person.",
+    "The court in Malawi shall apply the Public Roads Act throughout the territory.",
+    "2. Amendment of section 5 of Cap. 122A",
+    "publié au Journal Officiel et entre en vigueur sur tout le territoire.",
+    "10 dicembre 1948",
+    "Quarta-Feira de Cinzas continua a ser feriado nacional.",
+    "Phone: +1 202 555 0100 is the number appointed under this section.",
+    "Troubleshoot faulty system.",
+    "100 GENERAL PROVISIONS",
+    "applicable rule applies throughout the territory.",
+    "The register is published at www.example.com for public inspection under this Act.",
+    "بسم الله الرحمن الرحيم",
+    "Done at Brussels, 25 June 1999.",
+    "2",
+    "10",
+    "published in the Gazette.",
+    "Gazetted 1 October 2009",
+    "Lycée : séries ES, L et S",
+    "au Journal Officiel",
+    "Subs. ibid., for “local official Gazette”.",
+    "(a) books (excluding printed music and periodicals) ;",
+    "Act 19 Copyright and Neighbouring Rights Act 2006",
+)
+
+# One local-model window is 1024 tokens. Keep the prompt well under that.
+PROMPT_CHAR_BUDGET = 1600
+_PROMPT_PREFIX = (
+    "These lines survived legal-text normalization. "
+    'Propose JSON only: {"line_patterns": ["^...$"]}. '
+    "Each pattern must match one whole chrome line (page header, site footer, "
+    "printer stamp) and must not match a legal sentence. Do not write legal text. "
+    'If none are safe, return {"line_patterns": []}.\n'
+)
+
+
+def cache_packs(cache_dir: Path, slug: str | None = None) -> list[tuple[str, Path]]:
+    packs: list[tuple[str, Path]] = []
+    for path in sorted(cache_dir.glob("*_corpus.parquet")):
+        name = path.name[: -len("_corpus.parquet")]
+        if name in EXCLUDED_SLUGS or not name:
+            continue
+        if slug is not None and name != slug:
+            continue
+        packs.append((name, path))
+    return packs
+
+
+_HEADING_LINE = re.compile(
+    r"(?i)^(article|art\.|section|chapter|part|subtopic|§)\b"
+)
+_CHROME_HINT = re.compile(
+    r"(?i)(translated|serial number|copyright|gazette|https?://|www\.|"
+    r"\bpage\b|printed|journal officiel|série|series\b)"
+)
+# Repeated lines that are still the law, not a banner. The router must not see them.
+_PROVISION_LINE = re.compile(
+    r"(?i)(publi[eé]|lycée|lycee|newspaper|days after|série cei|série en |"
+    r"\bshall\b|\bmust\b|inserted sig|the gazette\.$|in the gazette\.$|"
+    r"\bgazetted\b|\bau journal officiel\b|subs\.\s*ibid|"
+    r"excluding printed|whether or not printed|neighbouring rights|"
+    r"série de classe|note de bas de page|communaut[eé]s europ)"
+)
+
+
+def scan_pack(path: Path, *, sample_lines: int = 40) -> dict[str, Any]:
+    """Count rows and keep the repeated short lines the script did not remove."""
+    import pyarrow.parquet as pq
+
+    pf = pq.ParquetFile(path)
+    if "body" not in set(pf.schema_arrow.names):
+        raise ValueError(f"{path.name} has no body column")
+    short: Counter[str] = Counter()
+    n = 0
+    n_changed = 0
+    n_unstable = 0
+    for batch in pf.iter_batches(batch_size=512, columns=["body"]):
+        for body in batch.column("body").to_pylist():
+            if body is None:
+                continue
+            original = body if isinstance(body, str) else str(body)
+            n += 1
+            normalized = normalize_legal_text(original)
+            if normalized != original:
+                n_changed += 1
+            if normalize_legal_text(normalized) != normalized:
+                n_unstable += 1
+            for line in normalized.splitlines():
+                stripped = line.strip()
+                if not stripped or len(stripped) > 60 or _HEADING_LINE.match(stripped):
+                    continue
+                if not _CHROME_HINT.search(stripped):
+                    continue
+                if stripped in short or len(short) < 20000:
+                    short[stripped] += 1
+    leftovers = [
+        {"line": line, "count": count}
+        for line, count in short.most_common(sample_lines)
+        if count >= 3
+    ]
+    return {
+        "n": n,
+        "n_changed": n_changed,
+        "n_unstable": n_unstable,
+        "leftovers": leftovers,
+    }
+
+
+def apply_pack(path: Path, out_path: Path) -> dict[str, Any]:
+    """Rewrite every body with the current script. No model is loaded."""
+    import pyarrow as pa
+    import pyarrow.parquet as pq
+
+    pf = pq.ParquetFile(path)
+    if "body" not in set(pf.schema_arrow.names):
+        raise ValueError(f"{path.name} has no body column")
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = out_path.with_suffix(out_path.suffix + ".partial")
+    writer = pq.ParquetWriter(tmp, pf.schema_arrow)
+    n = 0
+    n_changed = 0
+    try:
+        for batch in pf.iter_batches(batch_size=256):
+            bodies = batch.column("body").to_pylist()
+            rewritten: list[Any] = []
+            for body in bodies:
+                if body is None:
+                    rewritten.append(None)
+                    continue
+                original = body if isinstance(body, str) else str(body)
+                n += 1
+                normalized = normalize_legal_text(original)
+                if normalized != original:
+                    n_changed += 1
+                rewritten.append(normalized)
+            index = batch.schema.get_field_index("body")
+            arrays = [batch.column(i) for i in range(batch.num_columns)]
+            arrays[index] = pa.array(rewritten, type=batch.schema.field("body").type)
+            writer.write_batch(pa.record_batch(arrays, schema=batch.schema))
+    except Exception:
+        writer.close()
+        tmp.unlink(missing_ok=True)
+        raise
+    writer.close()
+    tmp.replace(out_path)
+    return {"n": n, "n_changed": n_changed}
+
+
+def _safe_pattern(pattern: str) -> bool:
+    if not isinstance(pattern, str) or not pattern.startswith("^") or not pattern.endswith("$"):
+        return False
+    if not 4 <= len(pattern) <= 180:
+        return False
+    if len(re.findall(r"\.\*|\.\+", pattern)) > 2:
+        return False
+    if re.search(r"\([^)]*[+*][^)]*\)[+*{]", pattern):
+        return False
+    try:
+        re.compile(pattern, re.IGNORECASE)
+    except re.error:
+        return False
+    return True
+
+
+def _blocked_candidate(line: str) -> bool:
+    """Publication sentences, headings, and mid-sentence fragments stay in the row."""
+    if _PROVISION_LINE.search(line) or _HEADING_LINE.match(line):
+        return True
+    if len(line) <= 3:
+        return True
+    return line.endswith((",", ";", " or", " and"))
+
+
+def accept_line_patterns(
+    proposals: Sequence[str],
+    leftovers: Sequence[str],
+    existing: Sequence[str] = (),
+    *,
+    must_hit: Sequence[str] | None = None,
+) -> list[str]:
+    """Keep a proposal only when it hits a leftover and misses every held-out sentence."""
+    accepted: list[str] = []
+    seen = set(existing)
+    pool = [line.strip() for line in leftovers if line and str(line).strip()]
+    required = pool if must_hit is None else [line.strip() for line in must_hit if line and str(line).strip()]
+    for pattern in proposals:
+        if pattern in seen or not _safe_pattern(pattern):
+            continue
+        compiled = re.compile(pattern, re.IGNORECASE)
+        if any(compiled.fullmatch(line.strip()) for line in KEEP_LINES):
+            continue
+        if compiled.fullmatch("2") or compiled.fullmatch("10"):
+            continue
+        hits = [line for line in pool if compiled.fullmatch(line)]
+        if not hits:
+            continue
+        if required and not any(compiled.fullmatch(line) for line in required):
+            continue
+        if any(_blocked_candidate(line) for line in hits):
+            continue
+        accepted.append(pattern)
+        seen.add(pattern)
+    return accepted
+
+
+def line_still_present(line: str) -> bool:
+    """True when the current script still leaves this exact line in place."""
+    probe = (
+        line
+        + "\nArticle 1 The present Act applies throughout the territory and binds every person."
+    )
+    normalized = normalize_legal_text(probe)
+    return line in normalized.splitlines()
+
+
+def router_candidates(
+    leftovers: Sequence[dict[str, Any]],
+    limit: int = 40,
+    *,
+    skip: set[str] | None = None,
+    presence: dict[str, bool] | None = None,
+) -> list[dict[str, Any]]:
+    """Banners the script still keeps, in leftover order, excluding provision lines."""
+    chosen: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    held = skip or set()
+    known = presence if presence is not None else {}
+    for item in leftovers:
+        line = str(item.get("line") or "").strip()
+        if not line or line in seen or line in held:
+            continue
+        if line not in known:
+            known[line] = line_still_present(line)
+        if not known[line] or _blocked_candidate(line):
+            continue
+        seen.add(line)
+        chosen.append({"line": line, "count": int(item.get("count") or 0)})
+        if len(chosen) >= limit:
+            break
+    return chosen
+
+
+def _cluster_key(line: str) -> str:
+    shape = re.sub(r"\d+", "0", line.casefold())
+    shape = re.sub(r"[^\w\s]+", " ", shape, flags=re.UNICODE)
+    shape = re.sub(r"\s+", " ", shape).strip()
+    return " ".join(shape.split()[:4])
+
+
+def largest_cluster(candidates: Sequence[dict[str, Any]], limit: int) -> list[dict[str, Any]]:
+    """The repeated family with the highest total count, capped to one prompt."""
+    groups: dict[str, list[dict[str, Any]]] = {}
+    for item in candidates:
+        groups.setdefault(_cluster_key(str(item["line"])), []).append(item)
+    best = max(groups.values(), key=lambda group: sum(int(item["count"]) for item in group))
+    best.sort(key=lambda item: int(item["count"]), reverse=True)
+    return best[:limit]
+
+
+def propose_line_patterns(
+    leftovers: Sequence[dict[str, Any]],
+    generate_text: GenerateText,
+    *,
+    char_budget: int = PROMPT_CHAR_BUDGET,
+) -> list[str]:
+    """One router call. The model proposes whole-line patterns, not statute text."""
+    if not leftovers:
+        return []
+    body: list[str] = []
+    used = len(_PROMPT_PREFIX)
+    for item in leftovers:
+        row = f"- {item['count']}× {item['line']}\n"
+        if used + len(row) > char_budget:
+            break
+        body.append(row)
+        used += len(row)
+    if not body:
+        room = max(0, char_budget - len(_PROMPT_PREFIX) - 16)
+        snippet = str(leftovers[0]["line"])[:room]
+        body.append(f"- {leftovers[0]['count']}× {snippet}\n")
+    raw = str(generate_text(_PROMPT_PREFIX + "".join(body)))
+    start, end = raw.find("{"), raw.rfind("}")
+    if start < 0 or end <= start:
+        return []
+    try:
+        payload = json.loads(raw[start : end + 1])
+    except json.JSONDecodeError:
+        return []
+    found = payload.get("line_patterns")
+    if not isinstance(found, list):
+        return []
+    return [item for item in found if isinstance(item, str)]
+
+
+def load_learned_patterns() -> list[str]:
+    path = learned_patterns_path()
+    if not path.is_file():
+        return []
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return []
+    return [item for item in payload.get("patterns") or [] if isinstance(item, str)]
+
+
+def save_learned_patterns(patterns: Sequence[str]) -> None:
+    path = learned_patterns_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps({"patterns": list(patterns)}, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    # The structure cache keys on mtime; the write updates it.
+
+
+def unresolved_path(report_dir: Path) -> Path:
+    return report_dir / "_unresolved.json"
+
+
+def load_unresolved(report_dir: Path) -> set[str]:
+    path = unresolved_path(report_dir)
+    if not path.is_file():
+        return set()
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return set()
+    return {item.strip() for item in payload.get("lines") or [] if isinstance(item, str) and item.strip()}
+
+
+def save_unresolved(report_dir: Path, lines: set[str]) -> None:
+    path = unresolved_path(report_dir)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps({"lines": sorted(lines)}, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+
+def collect_leftovers(report_dir: Path) -> list[dict[str, Any]]:
+    """Merge per-country residual lines. Counts for the same line are summed."""
+    counts: Counter[str] = Counter()
+    if not report_dir.is_dir():
+        return []
+    for path in sorted(report_dir.glob("*.json")):
+        if path.name.startswith("_"):
+            continue
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        for item in payload.get("leftovers") or []:
+            if isinstance(item, dict) and isinstance(item.get("line"), str):
+                line = item["line"].strip()
+                if line:
+                    counts[line] += int(item.get("count") or 0)
+    return [{"line": line, "count": count} for line, count in counts.most_common()]
+
+
+def improve_from_reports(
+    report_dir: Path,
+    generate_text: GenerateText,
+    *,
+    max_passes: int = 40,
+    batch_size: int = 12,
+    char_budget: int = PROMPT_CHAR_BUDGET,
+    on_pass: Callable[[dict[str, Any]], None] | None = None,
+    reset_unresolved: bool = False,
+) -> dict[str, Any]:
+    """Ask the router, one short batch at a time, for rules the script can apply.
+
+    A batch is one repeated family. Patterns that do not remove a line, or that
+    also match a publication sentence, are not stored. Families the model cannot
+    safely pattern are remembered so the next batch is a different family.
+    """
+    merged = collect_leftovers(report_dir)
+    pool_lines = [str(item["line"]) for item in merged]
+    presence: dict[str, bool] = {}
+    skip = set() if reset_unresolved else load_unresolved(report_dir)
+    existing = load_learned_patterns()
+    accepted_all: list[str] = []
+    removed_lines: list[str] = []
+    proposed = 0
+    passes = 0
+
+    def _emit(row: dict[str, Any]) -> None:
+        if on_pass is not None:
+            on_pass(row)
+
+    for pass_no in range(1, max(1, max_passes) + 1):
+        pending = router_candidates(merged, limit=100_000, skip=skip, presence=presence)
+        if not pending:
+            break
+        batch = largest_cluster(pending, batch_size)
+        cluster = _cluster_key(str(batch[0]["line"]))
+        _emit({
+            "event": "prompt",
+            "pass": pass_no,
+            "cluster": cluster,
+            "batch_id": hashlib.sha256(cluster.encode("utf-8")).hexdigest()[:8],
+            "candidates": len(batch),
+            "lines": [str(item["line"]) for item in batch],
+        })
+        try:
+            proposals = propose_line_patterns(batch, generate_text, char_budget=char_budget)
+        except Exception as exc:
+            passes += 1
+            _emit({"event": "pass", "pass": pass_no, "cluster": cluster, "error": str(exc)})
+            break
+        proposed += len(proposals)
+        accepted = accept_line_patterns(proposals, pool_lines, existing, must_hit=[str(item["line"]) for item in batch])
+        before = list(existing)
+        kept: list[str] = []
+        removed_now: list[str] = []
+        if accepted:
+            save_learned_patterns([*before, *accepted])
+            for pattern in accepted:
+                compiled = re.compile(pattern, re.IGNORECASE)
+                hits = [line for line in pool_lines if compiled.fullmatch(line)]
+                dropped = [line for line in hits if not line_still_present(line)]
+                if not dropped:
+                    continue
+                kept.append(pattern)
+                removed_now.extend(dropped)
+            if kept != accepted:
+                save_learned_patterns([*before, *kept])
+        if not kept:
+            skip.update(str(item["line"]) for item in batch)
+        else:
+            for line in removed_now:
+                presence[line] = False
+                skip.discard(line)
+                if line not in removed_lines:
+                    removed_lines.append(line)
+            existing = [*before, *kept]
+            accepted_all.extend(kept)
+        passes += 1
+        _emit({
+            "event": "pass",
+            "pass": pass_no,
+            "cluster": cluster,
+            "proposed": len(proposals),
+            "accepted": kept,
+            "removed": len(removed_now),
+        })
+
+    save_unresolved(report_dir, skip)
+    withheld = 0
+    for item in merged:
+        line = str(item["line"])
+        if line not in presence:
+            presence[line] = line_still_present(line)
+        if presence[line] and _blocked_candidate(line):
+            withheld += 1
+    remaining = router_candidates(merged, limit=100_000, skip=skip, presence=presence)
+    return {
+        "proposed": proposed,
+        "accepted": accepted_all,
+        "leftover_lines": len(merged),
+        "removed": len(removed_lines),
+        "removed_lines": removed_lines[:40],
+        "unresolved": len(skip),
+        "withheld": withheld,
+        "remaining": len(remaining),
+        "passes": passes,
+    }
+
+
+def worker_count(requested: int | None) -> int:
+    if requested is not None:
+        return max(1, int(requested))
+    return max(1, os.cpu_count() or 1)
+
+
+def _scan_job(job: tuple[str, str, str]) -> dict[str, Any]:
+    slug, path, report_dir = job
+    stats = scan_pack(Path(path))
+    write_scan(Path(report_dir), slug, stats)
+    return {"slug": slug, "n": stats["n"], "n_changed": stats["n_changed"], "n_unstable": stats["n_unstable"], "leftovers": len(stats["leftovers"])}
+
+
+def _apply_job(job: tuple[str, str, str]) -> dict[str, Any]:
+    slug, path, out_dir = job
+    out_path = Path(out_dir) / Path(path).name
+    stats = apply_pack(Path(path), out_path)
+    return {"slug": slug, "out": str(out_path), **stats}
+
+
+def run_parallel(
+    jobs: Sequence[tuple[str, str, str]],
+    worker,
+    workers: int | None,
+    *,
+    progress_path: Path | None = None,
+    on_done: Callable[[dict[str, Any]], None] | None = None,
+) -> list[dict[str, Any]]:
+    """One process per batch of countries. Each country writes its own file.
+
+    Progress is recorded in the parent as each country finishes, so a later
+    run can skip those slugs.
+    """
+    count = worker_count(workers)
+
+    def _finish(row: dict[str, Any]) -> dict[str, Any]:
+        if progress_path is not None:
+            append_progress(progress_path, row)
+        if on_done is not None:
+            on_done(row)
+        return row
+
+    if count == 1 or len(jobs) <= 1:
+        return [_finish(worker(job)) for job in jobs]
+    rows: list[dict[str, Any]] = []
+    with ProcessPoolExecutor(max_workers=min(count, len(jobs))) as pool:
+        futures = {pool.submit(worker, job): job[0] for job in jobs}
+        for future in as_completed(futures):
+            slug = futures[future]
+            try:
+                row = future.result()
+            except Exception as exc:
+                row = {"slug": slug, "error": str(exc)}
+            rows.append(_finish(row))
+    rows.sort(key=lambda row: str(row.get("slug") or ""))
+    return rows
+
+
+def write_scan(report_dir: Path, slug: str, stats: dict[str, Any]) -> Path:
+    report_dir.mkdir(parents=True, exist_ok=True)
+    path = report_dir / f"{slug}.json"
+    tmp = path.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps({"slug": slug, **stats}, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    tmp.replace(path)
+    return path
+
+
+def scan_done(report_dir: Path, slug: str) -> bool:
+    path = report_dir / f"{slug}.json"
+    if not path.is_file():
+        return False
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return False
+    return isinstance(payload.get("n"), int)
+
+
+def apply_done(out_dir: Path, slug: str) -> bool:
+    path = out_dir / f"{slug}_corpus.parquet"
+    if not path.is_file() or path.stat().st_size < 12:
+        return False
+    with path.open("rb") as handle:
+        if handle.read(4) != b"PAR1":
+            return False
+        handle.seek(-4, 2)
+        return handle.read(4) == b"PAR1"
+
+
+def append_progress(path: Path, row: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+        handle.flush()
+
+
+def load_generate_text() -> GenerateText:
+    """Import the router once per process. Scan and apply never call this."""
+    from ipfs_datasets_py.llm_router import generate_text
+
+    return generate_text
+
+
+def default_paths(root: Path) -> dict[str, Path]:
+    return {
+        "cache": root / "cache",
+        "reports": root / "reports" / "residuals",
+        "out": root / "llm-normalized",
+    }

country_laws_ir/package.py

@@ -253,7 +253,9 @@ def package_release(
         return file_descriptor(path, f"indexes/{name}")
 
     hub_id = target_repo(country["slug"])
-    edge_types = graph["stats"].get("edge_types") or [
+    bm25_stats = bm25.get("stats") if isinstance(bm25.get("stats"), dict) else {}
+    graph_stats = graph.get("stats") if isinstance(graph.get("stats"), dict) else {}
+    edge_types = graph_stats.get("edge_types") or [
         "HAS_JURISDICTION",
         "HAS_LANGUAGE",
         "BELONGS_TO_LAW",
@@ -270,10 +272,20 @@ def package_release(
         "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",
-        )},
+        "bm25": {
+            k: bm25_stats.get(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",
@@ -361,7 +373,17 @@ def package_release(
     if extra_manifest:
         manifest.update(extra_manifest)
     (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_readme(
+        out,
+        country,
+        source_meta,
+        counts,
+        bm25_stats,
+        graph_stats,
+        vectors.get("stats") if isinstance(vectors.get("stats"), dict) else {},
+        hub_id,
+        normalization_report=normalization_report,
+    )
     _write_gitattributes(out)
     _write_dataset_configs(out)
     return manifest
@@ -395,6 +417,55 @@ def _write_gitattributes(out: Path) -> None:
     )
 
 
+def _size_category(n: int) -> str:
+    if n < 1000:
+        return "n<1K"
+    if n < 10_000:
+        return "1K<n<10K"
+    if n < 100_000:
+        return "10K<n<100K"
+    if n < 1_000_000:
+        return "100K<n<1M"
+    if n < 10_000_000:
+        return "1M<n<10M"
+    return "n>10M"
+
+
+def _card_languages(normalization_report: dict[str, Any] | None) -> list[str]:
+    if not normalization_report:
+        return []
+    seen: list[str] = []
+    majority = str(normalization_report.get("document_language_majority") or "").strip()
+    breakdown = normalization_report.get("language_breakdown") or {}
+    ordered = []
+    if majority:
+        ordered.append(majority)
+    ordered.extend(
+        sorted(
+            (str(k) for k in breakdown if k),
+            key=lambda k: -int(breakdown.get(k) or 0),
+        )
+    )
+    for raw in ordered:
+        lang = str(raw).strip().lower().replace("_", "-").split("-")[0]
+        if lang and lang not in seen and lang not in {"und", "none", "null"}:
+            seen.append(lang)
+        if len(seen) >= 8:
+            break
+    return seen
+
+
+def _adj_glob(out: Path, direction: str) -> str:
+    aliases = {
+        "out": ("out", "outgoing"),
+        "in": ("in", "incoming"),
+    }
+    for name in aliases.get(direction, (direction,)):
+        if (out / "data" / "graph" / "adjacency" / name).is_dir():
+            return f"data/graph/adjacency/{name}/*.parquet"
+    return f"data/graph/adjacency/{direction}/*.parquet"
+
+
 def _write_readme(
     out: Path,
     country: dict[str, Any],
@@ -404,67 +475,49 @@ def _write_readme(
     graph_stats: dict[str, Any],
     vector_stats: dict[str, Any],
     hub_id: str,
+    normalization_report: dict[str, Any] | None = None,
 ) -> None:
     slug = country["slug"]
-    name = country["name"]
-    src = source_meta["source_dataset"]
-    rev = source_meta["source_revision"]
-    vec_status = vector_stats.get("status", "embedded")
+    name = country.get("name") or slug
+    src = source_meta.get("source_dataset") or ""
+    rev = source_meta.get("source_revision") or ""
+    vec_status = (vector_stats or {}).get("status", "embedded")
+    n_docs = int((counts or {}).get("corpus_rows") or 0)
+    languages = _card_languages(normalization_report)
+    import yaml
+
+    card = {
+        "license": "other",
+        "task_categories": ["text-retrieval"],
+        "tags": [
+            "legal",
+            "law",
+            "graphrag",
+            "bm25",
+            "research",
+            "not-legal-advice",
+            str(slug),
+        ],
+        "pretty_name": f"{name} laws IR (CID-keyed GraphRAG)",
+        "size_categories": [_size_category(n_docs)],
+        "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": _adj_glob(out, "out")}]},
+            {"config_name": "graph_incoming_adjacency", "data_files": [{"split": "train", "path": _adj_glob(out, "in")}]},
+        ],
+    }
+    if languages:
+        card["language"] = languages
+    front = yaml.safe_dump(card, sort_keys=False, allow_unicode=True)
     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
----
+{front}---
 
 # {name} legislation IR (CID-keyed sparse GraphRAG)
 
@@ -484,14 +537,14 @@ Target Hub id (packaging metadata only): `{hub_id}`.
 
 | 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}) |
+| Laws (corpus units) | {(counts or {}).get('n_laws', 0)} |
+| Articles (corpus units) | {(counts or {}).get('n_articles', 0)} |
+| Canonical docs | {(counts or {}).get('corpus_rows', 0)} |
+| BM25 terms | {(counts or {}).get('bm25_terms', 0)} |
+| BM25 postings | {(counts or {}).get('bm25_postings', 0)} |
+| Graph nodes | {(counts or {}).get('graph_nodes', 0)} |
+| Graph edges | {(counts or {}).get('graph_edges', 0)} |
+| Vectors | {(counts or {}).get('vector_rows', 0)} × {(vector_stats or {}).get('dimension', 384)}-d `{(vector_stats or {}).get('model_name', 'thenlper/gte-small')}` ({vec_status}) |
 
 ## Canonical fields
 
@@ -825,7 +878,7 @@ def package_release_sequential(
         "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 (
+        "bm25": {k: (bm25_stats or {}).get(k) for k in (
             "k1", "b", "title_weight", "body_weight", "average_document_length",
             "tokenizer", "max_query_terms", "posting_rows_per_record", "terms_per_shard",
         ) if k in bm25_stats},
@@ -900,7 +953,17 @@ def package_release_sequential(
     (out / "manifest.json").write_text(
         json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
     )
-    _write_readme(out, country, source_meta, counts, bm25_stats, gstats, vstats, hub_id)
+    _write_readme(
+        out,
+        country,
+        source_meta,
+        counts,
+        bm25_stats,
+        gstats,
+        vstats,
+        hub_id,
+        normalization_report=normalization_report,
+    )
     _write_gitattributes(out)
     _write_dataset_configs(out)
     checkpoint("package_seq_done")

country_laws_ir/profiles.py

@@ -27,13 +27,23 @@ _add("en", "title", "title")
 _add("en", "chapter", "chapter")
 _add("en", "part", "part")
 _add("en", "article", "article")
-_add("en", "section", "section", "sec.")
+_add("en", "section", "section", "sec.", "rule", "regulation", "schedule", "annex", "appendix")
+_add("fr", "section", "annexe")
+_add("es", "section", "anexo")
+_add("de", "section", "anlage")
+_add("nl", "section", "bijlage")
+_add("it", "section", "allegato")
+_add("pl", "section", "załącznik")
+_add("sv", "section", "bilaga")
+_add("fi", "section", "liite")
+_add("cs", "section", "příloha")
+_add("pt", "section", "anexo")
 
 _add("fr", "title", "titre")
 _add("fr", "chapter", "chapitre")
 _add("fr", "part", "partie")
 _add("fr", "article", "article")
-_add("fr", "section", "section")
+_add("fr", "section", "section", "paragraphe")
 
 _add("de", "title", "titel")
 _add("de", "chapter", "kapitel")
@@ -52,6 +62,7 @@ _add("es", "chapter", "capítulo", "capitulo")
 _add("es", "part", "parte")
 _add("es", "article", "artículo", "articulo")
 _add("es", "section", "sección", "seccion")
+_add("es", "article", "disposición", "disposicion")
 
 _add("pt", "title", "título", "titulo")
 _add("pt", "chapter", "capítulo", "capitulo")
@@ -66,26 +77,222 @@ _add("it", "article", "articolo")
 _add("it", "section", "sezione")
 
 _add("el", "article", "άρθρο", "αρθρο")
-_add("hu", "article", "szakasz")
+_add("el", "chapter", "κεφάλαιο")
+_add("hu", "article", "szakasz", "cikk")
 _add("cs", "article", "článek")
+_add("cs", "chapter", "kapitola")
+_add("cs", "section", "odstavec", "odst.")
 _add("sk", "article", "článok")
-_add("sl", "article", "član")
+_add("sl", "article", "člen")
 _add("nb", "article", "artikkel")
-_add("sv", "article", "artikel")
+_add("sv", "article", "paragraf")
+_add("fi", "article", "pykälä")
+_add("fi", "chapter", "luku")
+_add("is", "article", "grein")
+_add("lv", "article", "pants")
+_add("lv", "chapter", "nodaļa")
+_add("et", "article", "paragrahv")
+_add("et", "chapter", "peatükk")
 _add("pl", "article", "artykuł", "artykul")
 _add("ro", "article", "articolul", "articol")
-_add("zh", "article", "条")
-_add("ar", "article", "مادة", "المادة")
+_add("mt", "article", "artikolu")
+_add("zh", "article", "条", "條")
+_add("ar", "article", "مادة", "المادة", "الماده", "املادة", "املاده")
+_add("ar", "chapter", "الباب")
+_add("ar", "part", "الكتاب")
+_add("ar", "section", "الفصل", "ملحق", "الفرع")
+_add("fa", "article", "ماده")
+_add("fa", "section", "تبصره", "بند")
 _add("ja", "article", "条")
+_add("ko", "article", "조")
+_add("he", "article", "סעיף")
+_add("he", "chapter", "פרק")
+_add("he", "part", "חלק")
+_add("he", "section", "סימן", "תוספת", "תקנה")
+_add("th", "article", "มาตรา")
+_add("th", "chapter", "หมวด")
+_add("th", "section", "ข้อ", "วรรค")
+_add("hi", "article", "धारा")
+_add("bn", "article", "ধারা")
+_add("ru", "article", "статья")
+_add("ru", "chapter", "глава")
+_add("ru", "title", "раздел")
+_add("uk", "article", "стаття")
+_add("bg", "article", "член", "чл")
+_add("mk", "article", "член")
+_add("sr", "article", "члан")
+_add("hr", "article", "članak")
+_add("hr", "chapter", "poglavlje")
+_add("bs", "article", "članak")
+_add("sq", "article", "neni")
+_add("tr", "article", "madde")
+_add("az", "article", "maddə")
+_add("uz", "article", "модда")
+_add("mn", "article", "зүйл")
+_add("lo", "article", "ມາດຕາ")
+_add("id", "article", "pasal")
+_add("id", "chapter", "bab")
+_add("ms", "article", "seksyen")
+_add("ms", "part", "bahagian")
+_add("lt", "article", "straipsnis")
+_add("ta", "article", "பிரிவு")
+_add("el", "part", "μέρος")
+_add("el", "section", "παράγραφος")
+_add("uk", "title", "розділ")
+_add("zh", "chapter", "章")
+_add("ja", "chapter", "章")
+_add("ko", "chapter", "장")
+_add("vi", "article", "điều")
+_add("vi", "chapter", "chương")
+_add("ka", "article", "მუხლი")
+_add("hy", "article", "հոդված")
+_add("am", "article", "አንቀጽ")
+_add("km", "article", "មាត្រា")
+_add("my", "article", "ပုဒ်မ")
+_add("ne", "article", "दफा")
+_add("si", "article", "වගන්තිය")
+_add("kk", "article", "бап")
+_add("uz", "article", "modda")
+_add("be", "article", "артыкул")
+_add("ky", "article", "берене")
+_add("ur", "article", "دفعہ")
+_add("so", "article", "qodob", "qodobka")
+_add("ga", "article", "airteagal")
+_add("cy", "article", "erthygl")
+_add("fil", "article", "artikulo")
+_add("fil", "section", "seksyon")
+_add("fil", "chapter", "kabanata")
+_add("id", "part", "bagian")
+_add("vi", "part", "mục")
+_add("sw", "part", "sehemu")
+_add("ht", "article", "atik")
+_add("eu", "article", "artikulua")
+_add("da", "section", "stk")
+_add("nb", "section", "ledd")
+_add("de", "section", "absatz")
+_add("es", "section", "apartado")
+_add("it", "section", "comma")
+_add("tr", "section", "fıkra")
+_add("hr", "section", "stavak")
+_add("bg", "section", "ал")
+_add("te", "article", "ప్రకరణము", "ప్రకరణ")
+_add("kn", "article", "ಪ್ರಕರಣ")
+_add("gu", "article", "કલમ")
+_add("pa", "article", "ਧਾਰਾ")
+_add("ml", "article", "വകുപ്പ്")
+_add("th", "title", "ลักษณะ")
+_add("zh", "part", "编")
+_add("ja", "part", "編")
+_add("ko", "part", "편")
+_add("tg", "article", "модда")
+_add("sw", "article", "kifungu")
+_add("ca", "article", "article")
+_add("ca", "chapter", "capítol", "capitol")
+_add("ca", "title", "títol", "titol")
+_add("ca", "section", "secció", "seccio")
+_add("pl", "chapter", "rozdział")
+_add("pl", "title", "dział")
+_add("ro", "chapter", "capitolul")
+_add("ro", "title", "titlul")
+_add("it", "chapter", "capo")
+_add("cs", "chapter", "hlava")
+_add("sk", "chapter", "hlava")
+_add("es", "part", "libro")
+_add("sv", "chapter", "kap")
+_add("km", "chapter", "ជំពូក")
+_add("lo", "part", "ພາກ")
+_add("my", "chapter", "အခန်း")
+_add("ka", "chapter", "თავი")
+_add("hy", "chapter", "գլուխ")
+_add("am", "chapter", "ምዕራፍ")
+_add("sq", "chapter", "kreu")
+_add("hu", "chapter", "fejezet")
+_add("tr", "chapter", "bölüm")
+_add("az", "chapter", "fəsil")
+_add("lt", "chapter", "skyrius")
+_add("is", "chapter", "kafli")
+_add("ga", "chapter", "caibidil")
+_add("cy", "chapter", "pennod")
+_add("mt", "chapter", "kapitolu")
+_add("ht", "chapter", "chapit")
+_add("sw", "chapter", "sura")
+_add("nb", "chapter", "kapittel")
+_add("ha", "chapter", "sashe")
+_add("mg", "chapter", "andiany")
+_add("mi", "part", "wāhanga", "wahanga")
+_add("sm", "part", "vaega")
+_add("to", "article", "kupu")
+_add("fj", "chapter", "wase")
+_add("tpi", "part", "hap")
+_add("fo", "chapter", "kapittul")
+_add("bi", "article", "atikol")
+_add("rw", "article", "ingingo")
+_add("zu", "chapter", "isigaba")
+_add("xh", "chapter", "icandelo")
+_add("st", "part", "karolo")
+_add("tn", "chapter", "kgaolo")
+_add("sn", "part", "chikamu")
+_add("ny", "article", "ndime")
+_add("ku", "part", "beş")
+_add("ky", "chapter", "бөлүм")
+_add("tg", "chapter", "боби")
+_add("yo", "article", "abala")
+_add("yo", "chapter", "ori")
+_add("ig", "article", "nkeji")
+_add("lg", "part", "ekitundu")
+_add("om", "chapter", "kutaa")
+_add("ln", "part", "eténi", "eteni")
+_add("ti", "article", "ዓንቀጽ")
+_add("bm", "article", "sariya")
+_add("wo", "article", "tere")
+_add("ak", "article", "ahyɛde", "ahyede")
+_add("ee", "part", "akpa")
+_add("ff", "part", "faanda")
+_add("br", "article", "pennad")
+_add("kri", "section", "sekshon")
+_add("bo", "article", "དོན་ཚན")
+_add("ug", "article", "ماددا")
+_add("kw", "article", "erthygel")
+_add("tw", "article", "hyɛdeɛ", "hyedee")
+_add("tet", "article", "artigu")
+_add("haw", "article", "paukū", "pauku")
+_add("ty", "article", "irava")
+_add("ch", "part", "påtte", "patte")
+_add("es", "section", "numeral")
+_add("it", "section", "capoverso")
+_add("de", "section", "nummer")
+_add("so", "part", "qaybta")
+_add("vi", "part", "phần")
+_add("sk", "chapter", "oddiel")
+_add("el", "title", "τίτλος")
+_add("bg", "title", "дял")
+_add("uz", "chapter", "bob")
+_add("kk", "chapter", "тарау")
+_add("hi", "chapter", "अध्याय")
+_add("bn", "chapter", "অধ্যায়")
+_add("ur", "chapter", "باب")
+_add("fa", "chapter", "فصل")
+_add("ne", "chapter", "परिच्छेद")
+_add("zh", "section", "节")
+_add("ja", "section", "節")
+_add("ko", "section", "절")
+_add("th", "section", "ตอน")
+_add("sr", "part", "одељак")
+_add("be", "title", "раздзел")
 
 # Shared abbreviation; language left unknown.
-_add("und", "article", "art.")
+_add("und", "article", "art.", "član")
 _add("und", "section", "§")
 
 # Scripts we do not Latin-split:
-NO_LATIN_SPLIT_LANGS = frozenset({"ar", "zh", "zh-cn", "zh-tw", "ja", "ko", "fa", "he", "th", "hi", "bn", "am"})
+NO_LATIN_SPLIT_LANGS = frozenset(
+    {
+        "ar", "zh", "zh-cn", "zh-tw", "ja", "ko", "fa", "he", "th", "hi", "bn",
+        "am", "ru", "uk", "be", "ka", "hy", "km", "lo", "my", "si",
+    }
+)
 
-_TOKEN_RE = re.compile(r"[^\W\d_]{2,}|art\.|sec\.|§", re.UNICODE)
+_TOKEN_RE = re.compile(r"[^\W\d_]+|art\.|sec\.|чл\.|§", re.UNICODE)
 
 
 def classify_heading_token(token: str) -> list[tuple[str, str]]:

country_laws_ir/query.py

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

country_laws_ir/reconstruct.py

@@ -0,0 +1,229 @@
+"""Reconstruct empty parent law bodies from article children.
+
+Never invents legal text. Glue uses the same normalized strings as child
+corpus fields. Eligible empty parents always get a law row (full glue,
+streamed prefix, or title/number stub) — they are not dropped.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import os
+import re
+import unicodedata
+from typing import Any, Iterable
+
+from .structure import normalize_legal_text
+
+RECONSTRUCT_MAX_PARENT_CHARS = 2_000_000
+RECONSTRUCT_STUB_MAX_CHARS = 8_192
+RECONSTRUCT_PROCESS_BUDGET_BYTES = 512 * 1024 * 1024
+RSS_ABORT_SKIP_FULL_CONCAT = frozenset({"france", "eu", "denmark"})
+PARENT_TRUNCATED_MAX_CHARS = 40
+
+_DIGIT_FOLD = str.maketrans(
+    {
+        "٠": "0",
+        "١": "1",
+        "٢": "2",
+        "٣": "3",
+        "٤": "4",
+        "٥": "5",
+        "٦": "6",
+        "٧": "7",
+        "٨": "8",
+        "٩": "9",
+        "۰": "0",
+        "۱": "1",
+        "۲": "2",
+        "۳": "3",
+        "۴": "4",
+        "۵": "5",
+        "۶": "6",
+        "۷": "7",
+        "۸": "8",
+        "۹": "9",
+        "〇": "0",
+        "零": "0",
+    }
+)
+_NUM_RUN = re.compile(r"\d+|\D+")
+
+
+def fold_digits(value: str) -> str:
+    return unicodedata.normalize("NFKC", value or "").translate(_DIGIT_FOLD)
+
+
+def article_sort_key(article_number: str, source_id: str) -> tuple:
+    folded = fold_digits(article_number or "")
+    nums: list[int] = []
+    rest: list[str] = []
+    for run in _NUM_RUN.findall(folded) if folded else []:
+        if run.isdigit():
+            nums.append(int(run))
+        else:
+            rest.append(run)
+    if not folded:
+        return (0, (), "", source_id or "")
+    if nums:
+        return (1, tuple(nums), "".join(rest), source_id or "")
+    return (2, (), folded, source_id or "")
+
+
+def glue_piece(title: str, article_number: str, body: str) -> str:
+    """One child's contribution to a reconstructed parent (normalized strings)."""
+    title = title or ""
+    article_number = article_number or ""
+    body = body or ""
+    chunk = title if title else article_number
+    if chunk and not body.lstrip().startswith(chunk):
+        return f"{chunk}\n{body}" if body else chunk
+    return body
+
+
+def glue_parent(pieces: Iterable[str]) -> str:
+    return "\n\n".join(p for p in pieces if p)
+
+
+@dataclass
+class ReconstructResult:
+    body: str
+    reconstructed_from_articles: bool
+    reconstruction_truncated: bool
+    reconstruction_gap_note: str
+    reconstruction_article_count: int
+    reconstruction_article_ids: list[str] = field(default_factory=list)
+    reconstruction_article_sha256: list[str] = field(default_factory=list)
+    extra_bytes: int = 0
+    is_stub: bool = False
+
+    def extra_fields(self) -> dict[str, Any]:
+        return {
+            "reconstructed_from_articles": self.reconstructed_from_articles,
+            "reconstruction_truncated": self.reconstruction_truncated,
+            "reconstruction_gap_note": self.reconstruction_gap_note,
+            "reconstruction_article_count": self.reconstruction_article_count,
+            "reconstruction_article_ids": list(self.reconstruction_article_ids),
+            "reconstruction_article_sha256": list(self.reconstruction_article_sha256),
+        }
+
+
+def parent_needs_reconstruct(parent_body: str, n_articles: int) -> bool:
+    if n_articles < 1:
+        return False
+    body = parent_body or ""
+    return (not body) or len(body) < PARENT_TRUNCATED_MAX_CHARS
+
+
+def reconstruct_on() -> bool:
+    return os.environ.get("COUNTRY_LAWS_RECONSTRUCT", "1").strip() not in {"0", "false", "off"}
+
+
+def force_full_concat() -> bool:
+    return os.environ.get("COUNTRY_LAWS_RECONSTRUCT_FULL", "").strip() in {"1", "true", "on"}
+
+
+def process_budget_bytes() -> int:
+    raw = os.environ.get("RECONSTRUCT_PROCESS_BUDGET_BYTES")
+    if raw and raw.isdigit():
+        return int(raw)
+    return RECONSTRUCT_PROCESS_BUDGET_BYTES
+
+
+def reconstruct_parent(
+    *,
+    slug: str,
+    parent_body: str,
+    parent_title: str,
+    children: list[dict[str, str]],
+    running_extra_bytes: int,
+    sha256_hex,
+) -> ReconstructResult:
+    """Apply the five-way outcome table. ``children`` already normalized."""
+    ordered = sorted(
+        children,
+        key=lambda c: article_sort_key(c.get("article_number") or "", c.get("id") or ""),
+    )
+    ids = [c.get("id") or "" for c in ordered]
+    shas = [sha256_hex((c.get("body") or "").encode("utf-8")) for c in ordered]
+    n = len(ordered)
+    if n < 1 or not parent_needs_reconstruct(parent_body, n):
+        return ReconstructResult(
+            body=parent_body,
+            reconstructed_from_articles=False,
+            reconstruction_truncated=False,
+            reconstruction_gap_note="",
+            reconstruction_article_count=0,
+        )
+
+    stub_note = ""
+    if slug in RSS_ABORT_SKIP_FULL_CONCAT and not force_full_concat():
+        stub_note = "rss_abort_slug"
+    elif running_extra_bytes >= process_budget_bytes():
+        stub_note = "reconstruct_budget"
+
+    if stub_note:
+        parts: list[str] = []
+        if parent_title:
+            parts.append(parent_title)
+        for child in ordered:
+            label = child.get("title") or child.get("article_number") or ""
+            if label:
+                parts.append(label)
+        stub = "\n".join(parts)[:RECONSTRUCT_STUB_MAX_CHARS]
+        return ReconstructResult(
+            body=stub,
+            reconstructed_from_articles=True,
+            reconstruction_truncated=False,
+            reconstruction_gap_note=stub_note,
+            reconstruction_article_count=n,
+            reconstruction_article_ids=ids,
+            reconstruction_article_sha256=shas,
+            extra_bytes=0,
+            is_stub=True,
+        )
+
+    acc: list[str] = []
+    size = 0
+    truncated = False
+    for child in ordered:
+        piece = glue_piece(
+            child.get("title") or "",
+            child.get("article_number") or "",
+            child.get("body") or "",
+        )
+        if not piece:
+            continue
+        extra = (2 if acc else 0) + len(piece)
+        if size + extra > RECONSTRUCT_MAX_PARENT_CHARS:
+            room = RECONSTRUCT_MAX_PARENT_CHARS - size - (2 if acc else 0)
+            if room > 0:
+                acc.append(piece[:room])
+                size = RECONSTRUCT_MAX_PARENT_CHARS
+            truncated = True
+            break
+        acc.append(piece)
+        size += extra
+    body = glue_parent(acc)
+    return ReconstructResult(
+        body=body,
+        reconstructed_from_articles=True,
+        reconstruction_truncated=truncated,
+        reconstruction_gap_note="",
+        reconstruction_article_count=n,
+        reconstruction_article_ids=ids,
+        reconstruction_article_sha256=shas,
+        extra_bytes=len(body.encode("utf-8")),
+        is_stub=False,
+    )
+
+
+def expected_glue_from_children(children: list[dict[str, str]]) -> str:
+    ordered = sorted(
+        children,
+        key=lambda c: article_sort_key(c.get("article_number") or "", c.get("id") or ""),
+    )
+    return glue_parent(
+        glue_piece(c.get("title") or "", c.get("article_number") or "", c.get("body") or "")
+        for c in ordered
+    )

country_laws_ir/sparse.py

@@ -31,26 +31,33 @@ def corpus_to_bm25_rows(corpus: pd.DataFrame) -> list[dict[str, Any]]:
     """
     from ipfs_datasets_py.retrieval.hf_graphrag.bm25 import tokenize_bm25_text
 
-    _MAX_TITLE = 8_192
+    _MAX_TITLE = 4_096
     _MAX_BODY = 200_000
+    _CTRL = dict.fromkeys(range(32))
     rows: list[dict[str, Any]] = []
     for rec in corpus.itertuples(index=False):
-        title = str(getattr(rec, "title", "") or "").replace("\x00", "").strip()
-        body = str(getattr(rec, "body", "") or "").replace("\x00", "").strip()
+        cid = str(getattr(rec, "entry_cid", "") or "")
+        record_type = str(getattr(rec, "record_type", "") or "law")
+        title = str(getattr(rec, "title", "") or "").replace("\x00", "")
+        body = str(getattr(rec, "body", "") or "").replace("\x00", "")
+        title = title.translate(_CTRL).strip()
+        body = body.strip()
         if len(title) > _MAX_TITLE:
             title = title[:_MAX_TITLE].rstrip()
         if len(body) > _MAX_BODY:
             body = body[:_MAX_BODY].rstrip()
+        if not title:
+            title = f"{record_type} {cid}"[:_MAX_TITLE].strip()
         if not title and not body:
             continue
         if not tokenize_bm25_text(title) and not tokenize_bm25_text(body):
             continue
         rows.append(
             {
-                "entry_cid": str(rec.entry_cid),
+                "entry_cid": cid,
                 "title": title,
                 "body": body,
-                "record_type": str(getattr(rec, "record_type", "") or "law"),
+                "record_type": record_type,
                 "document_index": int(rec.document_index),
             }
         )

country_laws_ir/structure.py

@@ -20,6 +20,9 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from html.parser import HTMLParser
 import html as html_lib
+import json
+import os
+from pathlib import Path
 import re
 import unicodedata
 from typing import Any
@@ -27,24 +30,186 @@ from typing import Any
 _WS_RE = re.compile(r"\s+", re.UNICODE)
 _HAS_TAG_RE = re.compile(r"</?[a-zA-Z][^>]*>")
 
-# Line-anchored headings. Numbers may be arabic, roman, or dotted (1.2).
+# 1:1 map so match offsets stay aligned with the stored body. re.I does not
+# treat É as E; gazettes use Décision, Ordonnance, Điều, Člen, etc.
+_LATIN_FOLD = str.maketrans({
+    **dict.fromkeys("áàâäãåăąāấầẩẫậắằẳẵặảạ", "a"),
+    **dict.fromkeys("ÁÀÂÄÃÅĂĄĀẢẠ", "A"),
+    **dict.fromkeys("éèêëěęēếềểễệẻẹə", "e"),
+    **dict.fromkeys("ÉÈÊËĚĘĒẺẸƏ", "E"),
+    **dict.fromkeys("íìîïĩįīıịỉ", "i"),
+    **dict.fromkeys("ÍÌÎÏĨĮĪİỈỊ", "I"),
+    **dict.fromkeys("óòôöõőøōốồổỗộớờởỡợỏọ", "o"),
+    **dict.fromkeys("ÓÒÔÖÕŐØŌỎỌ", "O"),
+    **dict.fromkeys("úùûüűũūůứừửữựủụ", "u"),
+    **dict.fromkeys("ÚÙÛÜŰŨŪŮỦỤ", "U"),
+    **dict.fromkeys("ýÿỳỹỷỵ", "y"),
+    **dict.fromkeys("ÝŸỶỴ", "Y"),
+    **dict.fromkeys("çćčĉċ", "c"),
+    **dict.fromkeys("ÇĆČĈĊ", "C"),
+    **dict.fromkeys("ďđ", "d"),
+    **dict.fromkeys("ĎĐ", "D"),
+    **dict.fromkeys("ğĝģġ", "g"),
+    **dict.fromkeys("ĞĜĢĠ", "G"),
+    **dict.fromkeys("ñńņň", "n"),
+    **dict.fromkeys("ÑŃŅŇ", "N"),
+    **dict.fromkeys("ŕŗř", "r"),
+    **dict.fromkeys("ŔŖŘ", "R"),
+    **dict.fromkeys("śŝşšș", "s"),
+    **dict.fromkeys("ŚŜŞŠȘ", "S"),
+    **dict.fromkeys("ţťț", "t"),
+    **dict.fromkeys("ŢŤȚ", "T"),
+    **dict.fromkeys("źżž", "z"),
+    **dict.fromkeys("ŹŻŽ", "Z"),
+    **dict.fromkeys("ĺļľł", "l"),
+    **dict.fromkeys("ĹĻĽŁ", "L"),
+    "æ": "a", "Æ": "A", "œ": "o", "Œ": "O", "ß": "s",
+    "ɛ": "e", "Ɛ": "E", "ɔ": "o", "Ɔ": "O", "ŋ": "n", "Ŋ": "N",
+    **dict.fromkeys("ơớờởỡợ", "o"),
+    **dict.fromkeys("ƠỚỜỞỠỢ", "O"),
+    **dict.fromkeys("ưứừửữự", "u"),
+    **dict.fromkeys("ƯỨỪỬỮỰ", "U"),
+    **dict(zip("άέήίόύώϊϋΐΰ", "αεηιουωιυιυ")),
+    **dict(zip("ΆΈΉΊΌΎΏ", "ΑΕΗΙΟΥΩ")),
+    "ς": "σ",
+    "ё": "е", "Ё": "Е", "ї": "и", "Ї": "И", "є": "е", "Є": "Е", "ґ": "г", "Ґ": "Г",
+})
+
+
+def _latin_fold(text: str) -> str:
+    return text.translate(_LATIN_FOLD)
+
+# Headings at line start *or* after . ; : so compacted "Art. 1. … Art. 2." still splits.
+# Separator allows "Art. 1", "Art.1", "Član 12.", "ARTICULO 10.-", "Madde 1 –",
+# "Article (1)", French "Art. L. 111-1", Roman "ARTICLE I".
+_HEADING_NUM = (
+    r"(?:[0-9٠-٩۰-۹]+(?:er|ère|bis|ter|quater|o)?"
+    r"|(?-i:[IVXLCDM]{1,8})(?:er|ère)?(?![A-Za-z])"
+    r"|premier(?:e)?|première|primero|primeira"
+    r"|unique|unico|unica|único|única)"
+)
+_ARTICLE_N = (
+    r"(?:"
+    r"(?:[LRD]\.?\s*)?"
+    r"(?:"
+    r"[0-9٠-٩۰-۹]+(?:\.[0-9]+)?"
+    r"(?:er|ère|bis|ter|quater|aad|[A-Za-z]|o)?"
+    r"(?:/[0-9A-Za-z]+)?"
+    r"(?:\s+(?:bis|ter|quater))?"
+    r"|(?-i:[IVXLCDM]{1,8})(?:er|ère)?(?![A-Za-z])"
+    r"|[Α-Ω]{1,6}(?![Α-Ωα-ω])"
+    r")"
+    r"(?:[-–](?:[0-9]+|aad|bis|ter|quater|[A-Za-z](?![A-Za-z])))?"
+    r"(?:\([0-9A-Za-z]+\))?"
+    r"|premier(?:e)?"
+    r"|première"
+    r"|unique|unico|unica|único|única"
+    r"|primero|primera|primeiro|primeira"
+    r"|primo(?![A-Za-z])|secondo(?![A-Za-z])|terzo(?![A-Za-z])|quarto(?![A-Za-z])|quinto(?![A-Za-z])|prima(?![A-Za-z])"
+    r"|eerste|första|første"
+    r"|annexe"
+    r"|primera|segunda|tercera|cuarta|quinta"
+    r"|sexta|séptima|octava|novena|décima"
+    r")"
+)
+_HEADING_START = r"(?:^|(?<=[.;:])|(?<=\d[ \t]))[ \t\[\(\u00ab\u00bb\"“”‘’«»‹›\u2039\u203a]*"
 _HEADING_RE = re.compile(
-    r"(?im)^[ \t]*(?:"
-    r"(?P<title>TITLE|TITRE|TITEL|T[IÍ]TULO|TITOLO|T[IÍ]TUL)\s+"
-    r"(?P<title_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)"
-    r"|(?P<chapter>CHAPTER|CHAPITRE|KAPITEL|CAP[IÍ]TULO|CAPITOLO|HOOFDSTUK|CAP\.)\s+"
-    r"(?P<chapter_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)"
-    r"|(?P<part>PART|PARTIE|TEIL|PARTE|DEEL)\s+"
-    r"(?P<part_n>[0-9IVXLCDM]+[A-Za-z0-9.\-]*)"
-    r"|(?P<article>ART(?:ICLE|IKEL|ÍCULO|IGO|ICOLO|IKKEL)?\.?|ART\."
-    r"|ČLÁNEK|ČLÁNOK|ČLAN|SZAKASZ|ΆΡΘΡΟ|ΑΡΘΡΟ)\s+"
-    r"(?P<article_n>[0-9IVXLCDMΑ-Ω]+[A-Za-zΑ-Ωa-z0-9.\-]*)"
-    r"|(?P<section>SECTION|SECCI[OÓ]N|SEZIONE|ABSCHNITT|SEC\.)\s+"
-    r"(?P<section_n>[0-9A-Za-z.\-]+)"
-    r"|(?P<section_sym>§+)\s*(?P<section_sym_n>[0-9A-Za-z.\-]+)"
+    _latin_fold(
+    r"(?im)" + _HEADING_START + r"(?:"
+    r"(?P<title>TITLE|TITRE|TITEL|T[IÍ]TULO|TITOLO|TITLUL|T[IÍ]TUL|LUKU|PEAT[UÜ]KK|"
+    r"РАЗДЕЛ|РОЗДІЛ|DZIA[ŁL]|ΤΙΤΛΟΣ|ДЯЛ)\s+"
+    r"(?P<title_n>" + _HEADING_NUM + r"(?:\.[0-9]+|-(?:[0-9]+|[A-Za-z](?![A-Za-z])))?)"
+    r"|(?P<chapter>CHAPTER|CHAPITRE|KAPITEL|CAP[IÍ]TULO|CAPITOLO|HOOFDSTUK|"
+    r"ROZDZIA[ŁL]|CAPITOLUL|NODA[ĻL]A|GLAVA|ГЛАВА|POGLAVLJE|KAPITOLA|"
+    r"ΚΕΦΑΛΑΙ[ΟO]|CH[UƯ][OƠ]NG|BAB|KABANATA|CAPO|HLAVA|KREU|FEJEZET|"
+    r"B[ÖO]L[ÜU]M|FESIL|CAIBIDIL|PENNOD|KAPITOLU|CHAPIT|ODDIEL|"
+    r"SURA(?:\s+YA)?|KAPITTEL|KAPITTUL|ANDIANY|SASHE(?:\s+NA)?|WASE|"
+    r"ISIGABA|ICANDELO|KGAOLO|BOBI|KUTAA|ORI|CAP\.)\s+"
+    r"(?P<chapter_n>" + _HEADING_NUM + r"(?:\.[0-9]+|-(?:[0-9]+|[A-Za-z](?![A-Za-z])))?)"
+    r"|(?P<part>PART|PARTIE|TEIL|PARTE|DEEL|LIVRE|BOOK|BUCH|TOMO|KNIHA|"
+    r"KODEKS|CODE|ZAKONIK|BAHAGIAN|BAGIAN|SEHEMU|MỤC|MUC|LIBRO|PH[AẦ]N|"
+    r"QAYBTA|WAHANGA|VAEGA|HAP|KAROLO|CHIKAMU|BES|EKITUNDU|ETENI|"
+    r"AKPA|FAANDA|PATTE|ΜΕΡΟΣ)\s+"
+    r"(?P<part_n>" + _HEADING_NUM + r"(?:\.[0-9]+|-(?:[0-9]+|[A-Za-z](?![A-Za-z])))?)"
+    r"|(?P<article>(?:l['’])?(?:(?:EK|GEÇICI|GECICI|GEÇİCİ)\s+)?"
+    r"(?:ART(?:ICLE|IKEL|ÍCULO|ICULO|IGO|ICOLO|IKKEL|YKU[ŁL]|ICOLUL|ICOL|IKOLU|IKULA)?\.?"
+    r"|ART\.|NENI|PASAL|MADDE|MADDƏ|ĐIỀU|ĐIÊU|DIEU|CLANAK|ČLANAK|ČLÁNEK|ČLÁNOK|ČLEN|ČLAN|CLAN"
+    r"|ЧЛАНАК|ЧЛАН|ЧЛЕН|ЧЛ\.|СТАТЬЯ|СТАТТЯ|SZAKASZ|CIKK|ΆΡΘΡΟ|ΑΡΘΡΟ"
+    r"|PYKÄLÄ|GREIN|PANTS|SEKSYEN|CIKK|KIFUNGU|MODDA|ATIK|KUPU|ATIKOL|"
+    r"INGINGO(?:\s+YA)?|NDIME|ABALA|NKEJI|SARIYA|TERE|AHYEDE|PENNAD|ERTHYGEL|HYEDEE|"
+    r"ARTIGU|PAUKU|IRAVA"
+    r"|მუხლი|ՀՈԴՎԱԾ|Հոդված))(?![A-Za-z])"
+    r"(?:\s*(?:n\.?[o°º”'“*´`]|nr|no)\.?\s*)?\s*[.\s:–—-]*\(?\s*"
+    r"(?P<article_n>" + _ARTICLE_N + r")\)?"
+    r"|(?P<section>SUB(?:-)?SECTION|SECTION|SECCI[OÓ]N|SEZIONE|ABSCHNITT|PARAGRAHV|PARAGRAPHE|PARAGRAAF|PARAGRAPH|"
+    r"RECITAL|CONSIDERANDO|"
+    r"ALIN[EÉ]A|ALINEATUL|INCISO|P[AÁ]RRAFO|PUNKT(?![A-Za-z])|SATZ(?![A-Za-z])|LID|"
+    r"ΠΑΡΑΓΡΑΦΟΣ|ABSATZ|APARTADO|COMMA(?![A-Za-z])|FIKRA|STAVAK|STK\.?|АЛ\.|SEKSHON|"
+    r"NUMERAL|CAPOVERSO|NUMMER|"
+    r"AYAT|KHOẢN|KHOAN|"
+    r"RULE(?![A-Za-z])|REGULATION(?![A-Za-z])|SCHEDULE(?![A-Za-z])|FORM(?![A-Za-z])|"
+    r"ORDINANCE|ORDONNANCE|ORDONAN[TŢȚ][AĂÁ]?|ORDIN(?![A-Za-z])|BY-?LAW|DIRECTIVE(?![A-Za-z])|"
+    r"D[EÉ]CISION(?![A-Za-z])|DECISION(?![A-Za-z])|DECIZIE|"
+    r"BESLUIT(?![A-Za-z])|REGELING(?![A-Za-z])|BESCHIKKING(?![A-Za-z])|"
+    r"ODLUKA|PRAVILNIK|HOT[ĂA]R[ÂAÎI]RE|"
+    r"RESOLUCI[OÓ]N(?![A-Za-z])|RESOLU[CÇ][AÃ]O(?![A-Za-z])|PORTARIA(?![A-Za-z])|ACUERDO(?![A-Za-z])|"
+    r"MEDIDA\s+PROVIS[OÓ]RIA|"
+    r"PROCLAMATION(?![A-Za-z])|PROKLAMATION|CIRCULAR(?![A-Za-z])|INSTRUCTION(?![A-Za-z])|"
+    r"GUIDELINE(?![A-Za-z])|MEMORANDUM(?![A-Za-z])|"
+    r"AVISO(?![A-Za-z])|AVIS(?![A-Za-z])|BEKANNTMACHUNG|MEDDELANDE|"
+    r"NORMA(?![A-Za-z])|"
+    r"PRESIDENTIAL\s+DECREE|DECRETO-LEI|DECRETO(?![A-Za-z])|DECREE(?![A-Za-z])|"
+    r"D[EÉ]CRET-LOI|D[EÉ]CRET(?![A-Za-z])|ARR[EÊ]T[EÉ]|"
+    r"DELIBERA[CÇ][AÃ]O|D[EÉ]LIB[EÉ]RATION|COMUNICADO|"
+    r"R[EÈ]GLEMENT(?![A-Za-z])|CIRCULAIRE(?![A-Za-z])|VERORDNUNG(?![A-Za-z])|ERLASS(?![A-Za-z])|"
+    r"PUNTO(?![A-Za-z])|SUB(?:-)?PARAGRAPH|"
+    r"ANNEX(?:E)?(?![A-Za-z])|ANEXO|ANLAGE|BIJLAGE|APPENDIX|ALLEGATO|"
+    r"ZA[ŁL][AĄ]CZNIK|BILAGA|LIITE|P[ŘR][IÍ]LOHA|"
+    r"UST\.|ODST\.|ODS\.|BEK\.|"
+    r"SEC(?:\.|(?=\s+[0-9])))(?![A-Za-z])(?:\s*(?:n\.?[o°º”'“*´`]|nr|no)\.?\s*)?[.\s:]*\(?\s*"
+    r"(?P<section_n>(?:[0-9][0-9A-Za-z.\-]*(?:\([0-9A-Za-z]+\))?|"
+    r"(?-i:[IVXLCDM]{1,8})(?![A-Za-z])|[A-Za-z](?![A-Za-z])))\)?"
+    r"|(?P<section_sym>§+)\s*(?P<section_sym_n>[0-9]+(?:[A-Za-z](?![A-Za-z]))?(?:\s+[A-Za-z](?![A-Za-z]))?(?:\s*\([0-9A-Za-z]+\))?)"
+    r"|(?P<section_pre_n>[0-9]+(?:\s*[a-z])?)\s*\.?\s*(?P<section_pre>§)"
+    r"|(?P<grein_n>[0-9]+[a-z]?)\s*\.\s*(?P<grein>gr|pants)\.?"
+    r"|(?P<straipsnis_n>[0-9]+[a-z]?)\s*[.]?\s*(?P<straipsnis>straipsnis)"
+    r"|(?P<artikulua_n>[0-9]+[a-z]?)\s*[.]?\s*(?P<artikulua>artikulua)"
+    r"|(?P<ledd_n>[0-9]+)\s*[.]?\s*(?P<ledd>ledd)"
+    r"|(?P<kap_n>[0-9]+)\s*(?P<kap>kap)\.?"
+    r"|(?P<luku_n>[0-9]+)\s*(?P<luku>luku)"
+    r"|(?P<fejezet_n>[IVXLCDM0-9]+)\s*\.\s*(?P<fejezet>fejezet)"
+    r"|(?P<peatukk_n>[0-9]+)\s*[.]?\s*(?P<peatukk>peat[uü]kk)"
+    r"|(?P<skyrius_n>[IVXLCDM0-9]+)\s*(?P<skyrius>skyrius)"
+    r"|(?P<nodala_n>[IVXLCDM0-9]+)\s*(?P<nodala>noda[ļl]a)"
+    r"|(?P<kafli_n>[IVXLCDM0-9]+)\s*[.]?\s*(?P<kafli>kafli)"
+    r"|(?P<bob_n>[0-9]+)\s*-\s*(?P<bob>bob)"
+    r"|(?P<tarau_n>[0-9]+)\s*-\s*(?P<tarau>тарау)"
+    r"|(?P<bolum_n>[0-9]+)\s*-\s*(?P<bolum>бөлүм)"
+    r"|(?P<modda_n>[0-9]+)\s*-\s*(?P<modda>модда|modda)"
+    r"|(?P<mn_n>[0-9]+)\s*(?P<mn>(?:дүгээр|дугаар)\s*зүйл)"
+    r"|(?P<kk_n>[0-9]+)\s*-?\s*(?P<kk>бап)"
+    r"|(?P<mom_n>[0-9]+)\s*(?P<mom>momentti)"
+    r"|(?P<order>(?:EXECUTIVE\s+)?ORDER)\s+(?P<order_n>[0-9]+)"
+    r"|(?P<kidogo>KIFUNGU\s+KIDOG[OU])\s*\(?\s*(?P<kidogo_n>[0-9]+)"
+    r"|(?P<disp>DISPOSICI[OÓ]N)(?:\s+(?:adicional(?:es)?|transitoria(?:s)?|derogatoria(?:s)?|final(?:es)?))?\s+"
+    r"(?P<disp_n>" + _ARTICLE_N + r")"
+    r"|(?P<esresol>primero|segundo|tercero|cuarto|quinto|sexto|septimo|octavo|noveno|decimo|"
+    r"erstens|zweitens|drittens|viertens|funftens|"
+    r"premierement|deuxiemement|troisiemement|quatriemement|cinquiemement)\s*:"
     r")"
-    r"(?P<rest>[^\n]{0,200})?"
+    )
+)
+# Commonwealth "1. Short title" — used only when keyword headings are scarce.
+_CW_NUM_RE = re.compile(
+    r"(?m)^[ \t]*(?P<cw_n>[0-9]+[A-Za-z]?)\.?\s+(?:\([0-9A-Za-z]+\)\s+)?(?=[A-Z][a-z]+)"
+)
+_MONTH_START_RE = re.compile(
+    r"(?i)^(january|february|march|april|may|june|july|august|september|october|november|december|"
+    r"janvier|f[eé]vrier|marzo|abril|enero|junio|julio)\b"
 )
+_CW_NUM_LANGS = frozenset({"", "en", "hi", "bn", "ne", "ur", "ms", "fil", "sw", "si"})
+_LEXICON_HEADING_RE: re.Pattern[str] | None = None
+_LEXICON_KIND: dict[str, str] = {}
 
 _SUBSECTION_RE = re.compile(r"\(([0-9A-Za-z]{1,6})\)")
 
@@ -60,15 +225,733 @@ _KIND_RANK = {
 MIN_SPLIT_HEADINGS = 2
 MIN_UNIT_CHARS = 40
 
+# Markers on the *stored* body (no rewritten newline copy).
 _ZH_ART_RE = re.compile(
-    r"(?:(?<=\n)|^)[ 　]*"
-    r"(第[一二三四五六七八九十百千万零〇两0-9]+条(?:之[一二三四五六七八九十百0-9]+)?)"
+    r"第\s*[一二三四五六七八九十百千万零〇两0-9]+\s*[条條](?:之[一二三四五六七八九十百0-9]+)?"
+)
+_AR_ORD = (
+    r"(?:الحادية|الثانية|الثالثة|الرابعة|الخامسة|السادسة|السابعة|الثامنة|التاسعة)[\s\u0640]*والعشرون|"
+    r"(?:الحادية|الثانية|الثالثة|الرابعة|الخامسة|السادسة|السابعة|الثامنة|التاسعة)[\s\u0640]*عشرة|"
+    r"العشرون|"
+    r"الأولى|الأولي|األولى|الاولى|الثانية|الثالثة|الرابعة|الخامسة|"
+    r"السادسة|السابعة|الثامنة|التاسعة|العاشرة"
+)
+_AR_ORD_M = (
+    r"الأول|الاول|الثاني|الثالث|الرابع|الخامس|"
+    r"السادس|السابع|الثامن|التاسع|العاشر"
 )
 _AR_ART_RE = re.compile(
-    r"(?:(?<=\n)|^)[ \t]*(المادة|مادة)\s*([0-9٠-٩]+)"
+    r"\(?(?:الماد[ةه]|املاد[ةه]|مادة)\s*[-–]?\s*[()]*\s*(?:[0-9٠-٩۰-۹]+|" + _AR_ORD + r")"
+    r"(?:\s*[-–])?(?:\s*[()]*)?(?:\s*مكرر(?:اً|ا)?)?"
+)
+_CITE_TAIL_RE = re.compile(
+    _latin_fold(
+        r"(?i)\s+(?:"
+        r"of\s+(?:this\s+|the\s+)?(?:act|law|agreement|code|constitution|article|section|"
+        r"principal\s+act|ordinance|regulation|decree|chapter|part|title|ruling|order)"
+        r"|thereof\b"
+        r"|hereof\b"
+        r"|hereunder\b"
+        r"|de\s+la\s+(?:loi|ley|presente|présente)"
+        r"|du\s+(?:code|présent|present)"
+        r"|des\s+gesetzes"
+        r"|van\s+(?:deze\s+)?(?:wet|artikel)"
+        r"|i\s+lov\b"
+        r"|cua\s+luat(?:\s+nay)?"
+        r")\b"
+    )
+)
+_NUMERO_FOLD_RE = re.compile(
+    r"(?i)(?:№|n\.\s*o\b|n\.?[°º]|nÂ[oº°]|\bno\.?\s+(?=\d))\.?\s*"
+)
+_CJK_RANGE_RE = re.compile(
+    r"第\s*[一二三四五六七八九十百千万零〇两0-9]+\s*[条條]\s*(?:至|到|から)\s*"
+    r"第\s*[一二三四五六七八九十百千万零〇两0-9]+\s*[条條](?:まで)?"
+)
+_FA_ORD = (
+    r"یازدهم|دوازدهم|سیزدهم|چهاردهم|پانزدهم|شانزدهم|هفدهم|هجدهم|نوزدهم|بیستم|"
+    r"اولی?|نخست|دوم|سوم|چهارم|چارم|جارم|پنجم|ششم|هفتم|هشتم|نهم|دهم"
+)
+_FA_ART_RE = re.compile(r"(?:ماده|مادة)\s*(?:[0-9۰-۹]+|" + _FA_ORD + r")")
+_DA_ART_RE = re.compile(r"(?:Artikel|§)\s*[0-9]+", re.IGNORECASE)
+_CHROME_LINE_RE = re.compile(
+    r"(?i)^(?:"
+    r"početna stranica\b.*|"
+    r"upute za korištenje\b.*|"
+    r"elektronička pošta\b.*|"
+    r"vsebina uradnega lista\b.*|"
+    r"the incident id is\b.*|"
+    r"ωράριο λειτουργίας\b.*|"
+    r"τηλέφωνο επικοινωνίας\b.*|"
+    r"skip to (?:main )?content\b.*|"
+    r"javascript is (?:required|disabled)\b.*|"
+    r"privacy policy\s*$|"
+    r"traduction française pour information\s*$|"
+    r"pdf\s*$|"
+    r"https?://\S+\s*$|"
+    r"légimonaco\b.*|"
+    r"statutory instruments\s*$|"
+    r"official gazette\s*$|"
+    r"government gazette\s*$|"
+    r"(?:the )?london gazette\s*$|"
+    r"journal officiel(?: de la république(?: [^\n]{0,40})?)?\.?\s*$|"
+    r"bulletin officiel\s*$|"
+    r"gazette du canada\s*$|"
+    r"(?:the )?[\w .'-]{0,50}gazette\s*$|"
+    r"الوقائع المصرية\s*$|"
+    r"الوقائع العراقية\b.*|"
+    r"العدد\s*$|"
+    r"العدد\s+\S.{0,80}الوقائع\b.*|"
+    r".*شعبة الجريدة الرسمية\s*$|"
+    r"(?:the )?(?:republic of sudan gazette|gazette published by authority|official gazette of the republic of sudan)\b.*|"
+    r"الصفحة(?:\s*[0-9٠-٩]+)?\s*$|"
+    r"(?:الجريدة|اجلريدة|جريدة)(?:\s+الر\s*سمية)?(?:\s+العدد(?:\s*\(\s*\)?\s*[0-9٠-٩]+)?)?\s*$|"
+    r"république du s[ée]n[ée]gal\s*$|"
+    r"jamhuuriyadda\b.*|"
+    r"warta kerajaan\s*$|"
+    r"lembaran negara\s*$|"
+    r"berita negara\s*$|"
+    r"công báo\s*$|"
+    r"la gaceta\s*$|"
+    r"no\.?\s*\d+\s+government gazette\b.*|"
+    r"supplement to (?:the |official ).{0,60}gazette\b.*|"
+    r"[a-z0-9 ,.'()-]*supplement to official gazette[a-z0-9 ,.'()-]*$|"
+    r"printed by\b.*|"
+    r"https?://\S+(?:\s+\d+(?:\.\d+)*)?\s*$|"
+    r"©+\s*.*congress\b.*|"
+    r"(?:s|sm)\s+congress\b.*|"
+    r"palikir,\s*pohnpei\b.*|"
+    r"www\.\S+(?:\s+\d+)?\s*$|"
+    r"at\s+www\.\S+\s*$|"
+    r".*research bulletin.*|"
+    r"acts supplement\s*$|"
+    r"supplement\s+(?:nr\.\s*|no\.?\s*)\d+(?:\s+\d{1,2}(?:st|nd|rd|th)\s+[a-z]+,?\s+\d{4}\.?)?\s*$|"
+    r"no\.\s+of\s+\d{4}\.?\s*$|"
+    r"act no\.\s+of\s+\d{4}\.?\s*$|"
+    r"bill for the\s*$|"
+    r"(?:the )?republic of [a-z]+(?:\s+[a-z]+)?\s*$|"
+    r"federal republic of [a-z]+(?:\s+[a-z]+)?\s*$|"
+    r"democratic people's republic of korea\s*$|"
+    r".{0,10}republic of palau\s*$|"
+    r"saint vincent and the grenadines\s*$|"
+    r"\[?\s*član\s+\.\.\.\s*\]?\s*$|"
+    r".*аудиони тинглаш.*|"
+    r"reprint\s*$|"
+    r"reprint authorised by\b.*|"
+    r"parliament building\s*$|"
+    r"oau drive, tower hill\s*$|"
+    r"office of the clerk of parliament\s*$|"
+    r"(?:(?:first|second|third|fourth|fifth)\s+parliament(?:\s+of\s+the\s+(?:first|second|third|fourth|fifth)\s+republic)?\s*){1,2}$|"
+    r"(?:(?:first|second|third|fourth|fifth)\s+meeting of parliament\s*){1,2}$|"
+    r"تفاصيل\s+(?:النظام|اللائحة)\s*$|"
+    r"مجموعة الأنظمة السعودية\s*$|"
+    r"المجلد\s+\S+\s*$|"
+    r"أنظمة\s+\S.{0,60}$|"
+    r"(?:first|second|third|fourth|fifth|sixth|seventh|eighth|ninth|tenth)\s+folder\s*$|"
+    r"this law includes:\s*$|"
+    r"-\s*اختر\s*-\s*$|"
+    r"تاريخ الإصدار\s*$|"
+    r"تاريخ النشر\s*$|"
+    r"الحالة\s*$|"
+    r"ساري\s*$|"
+    r"العربية\s*$|"
+    r"الإسم\s*$|"
+    r"البريد الإلكتروني\s*$|"
+    r"رقم الجوال\s*$|"
+    r"نوع البلاغ\s*$|"
+    r"\d{4}/\d{2}/\d{2}\s+ه\s+الموافق\s*:?\s*\d{2}/\d{2}/\d{4}\s+م\s*$|"
+    r"\d{3,4}\s+ه\s*$|"
+    r"خطأ لغوي\s*$|"
+    r"خطأ في مادة\s*$|"
+    r"يتضمن (?:النظام|التنظيم) ما يلي\s*:?\s*$|"
+    r"عدد مرات التصفح\s*\d*\s*$|"
+    r"نبذة عن النظام\s*$|"
+    r"اسم النظام/اللائحة\b.*|"
+    r"تاريخ (?:إصدار|نشر) النظام/اللائحة\s*$|"
+    r"حالة النظام/اللائحة\b.*|"
+    r"أدوات إصدار النظام\s*$|"
+    r"نص النظام\s*$|"
+    r"مادة معدلة\s*$|"
+    r"مادة ملغية\s*$|"
+    r"اصل الوثيقة\s*$|"
+    r"طباعة\s*$|"
+    r"إبلاغ\s*$|"
+    r"الإصدارات\s*$|"
+    r"اللغات\s*$|"
+    r"الإنجليزية\s*\(English\)\s*$|"
+    r"(?:\d{4}\s+)?revised edition(?:\s+as at\b.*|\s+page\s+\d+)?\s*$|"
+    r"page\s+\d+\s+\d{4}\s+revised edition\s*$|"
+    r"\[note: this version\b.*|"
+    r"\[this is the version of this document\b.*|"
+    r"el peruano\s*$|"
+    r"(?:act\s+\d+\s+of\s+\d{4}\s+)?page\s*\d+(?:\s+(?:of\s+\d+|act\s+\d+\s+of\s+\d{4}|[a-z]))?\s*$|"
+    r"[a-z]\s+page\s*\d+\s*$|"
+    r"(?:section\s+)?pages?\s*$|"
+    r"seite\s+\d+(?:\s+(?:von|of|bis)\s+\d+)?\s*$|"
+    r"bundesrecht konsolidiert\b.*|"
+    r".*ris\.bka\.gv\.at.*$|"
+    r"\{\\rtf\d+\b.*|"
+    r"p[aá]gina\s+\d+\s*$|"
+    r"pagina\s+\d+\s*$|"
+    r"strona\s+\d+\s*$|"
+    r"p\.\s*\d+(?:\s+(?:of|di|von|sur|de)\s+\d+)?\s*$|"
+    r"pag\.\s*\d+(?:\s+(?:di|of|de)\s+\d+)?\s*$|"
+    r"blz\.\s*\d+\s*$|"
+    r"folio\s+\d+\s*$|"
+    r"foglio\s+\d+\s*$|"
+    r"лист\s+\d+\s*$|"
+    r"стр\.\s*\d+\s*$|"
+    r"ص\s*\.?\s*\d+\s*$|"
+    r"עמוד\s+\d+\s*$|"
+    r"trang\s+\d+\s*$|"
+    r"halaman\s+\d+\s*$|"
+    r"sayfa\s+\d+\s*$|"
+    r"oldal\s+\d+\s*$|"
+    r"stran(?:ica)?\s+\d+\s*$|"
+    r"www\.\S+\s*$|"
+    r"downloaded from\b.*|"
+    r"printed on\s+\d.*|"
+    r"generated by\b.*|"
+    r"e-?mail:\s*\S+@\S+\s*$|"
+    r"tel(?:ephone)?:\s*[+\d].*$|"
+    r"for more information visit\b.*|"
+    r"[-–—]\s*\d{1,4}\s*[-–—]\s*$|"
+    r"table of contents\s*$|"
+    r"table des mati[eè]res\s*$|"
+    r"inhaltsverzeichnis\s*$|"
+    r"(?:índice|indice)\s*$|"
+    r"sommaire\s*$|"
+    r".*\barrangement of (?:sections|provisions|regulations|rules)\.?(?:\s+cap\.\s*[\d.]+.*)?\s*$|"
+    r"contents\s*$|"
+    r"section\s*$|"
+    r"[\s.\-;,*/_×|+~•·{}()\\=»«®∞]+$|"
+    r"(?=.*[+|])[+\-|]{3,}\s*$|"
+    r"\[original service \d{4}\].*|"
+    r"statute law of the [a-z ]+$|"
+    r"[A-Z][A-Z .'\-]{0,40}\[ch\.\s*\d+.*|"
+    r"التاريخ:\s*$|"
+    r"republic of the marshall islands\s*$|"
+    r"jepilpilin ke ejukaan\s*$|"
+    r"zastupni[cč]ki dom hrvatskoga sabora\s*$|"
+    r"dr[zž]avni zavod za normizaciju i mjeriteljstvo\s*$|"
+    r"олдинги таҳрирга қаранг\.?\s*$|"
+    r"explanatory note\s*$|"
+    r"\.\s*\(\s*\d+\s*\)\s*$|"
+    r"(?:يناير|فبراير|مارس|أبريل|ابريل|مايو|يونيو|يوليو|أغسطس|اغسطس|سبتمبر|أكتوبر|اكتوبر|نوفمبر|ديسمبر)\s+\d{4}\s*$|"
+    r"laws of (?:the )?[a-z]+(?:\s+(?:&|[a-z]+)){0,4}\s*$|"
+    r"(?-i:LAWS OF (?:THE )?[A-Z]+(?:\s+[A-Z]+){0,6}\s+s\s*\d+\s*$)|"
+    r"(?:í|i)ndice legislativo\s*$|"
+    r"قائمة (?:المحتويات|احملتويات)\s*$|"
+    r"spis tre[sś]ci\s*$|"
+    r"содержание\s*$|"
+    r"πίνακας περιεχομένων\s*$|"
+    r"목차\s*$|"
+    r"目次\s*$|"
+    r"สารบัญ\s*$|"
+    r"[aα]ριθμός\s+\d+[^\n]{0,24}\s*$|"
+    r"[aα]ρ\.\s*\d+(?:/\d+)?[^\n]{0,12}\s*$|"
+    r"številka\s+\d+[^\n]{0,24}\s*$|"
+    r"(?:nr|no|n[uú]m(?:ero|éro|ber)?|broj|č[ií]slo|szám|sayı|номер)\.?\s*\d{2,}(?:/\d+)?[.\s]*$|"
+    r"№\s*\d+\s*$|"
+    r"copyright\s*©?\s*\d{4}.*$|"
+    r"©\s*\d{4}.*$|"
+    r"\d{1,2}[./-]\d{1,2}[./-]\d{2,4}\s*$|"
+    r"\d{4}-\d{2}-\d{2}\s*$|"
+    r"\d{1,2}\s+(?:january|february|march|april|may|june|july|august|september|october|november|december|"
+    r"janvier|f[eé]vrier|mars|avril|mai|juin|juillet|ao[uû]t|septembre|octobre|novembre|d[eé]cembre|"
+    r"enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|octubre|noviembre|diciembre)\s+\d{4}\s*$|"
+    r"end of (?:the )?document\s*$|"
+    r"fin du document\s*$|"
+    r"ende des dokuments?\s*$|"
+    r"fin del documento\s*$|"
+    r"fim do documento\s*$|"
+    r"[-*=._]{3,}\s*$|"
+    r"published\s*$|"
+    r"publi[eé]\s*$|"
+    r"publicado\s*$|"
+    r"veröffentlicht\s*$|"
+    r"\[?seal\]?\s*$|"
+    r"\(seal\)\s*$|"
+    r"l\.s\.?\s*$|"
+    r"god save the (?:king|queen)\s*$|"
+    r"vive la r[eé]publique\s*$|"
+    r"by (?:order|command)\s*$|"
+    r"signed\s*$|"
+    r"diario oficial(?: de la federación)?\s*$|"
+    r"gazzetta ufficiale(?: della repubblica(?: italiana)?)?\s*$|"
+    r"boletín oficial(?: del estado)?\s*$|"
+    r"diário da república\s*$|"
+    r"bundesgesetzblatt\s*$|"
+    r"moniteur belge\s*$|"
+    r"belgisch staatsblad\s*$|"
+    r"staatsblad\s*$|"
+    r"lovtidende\s*$|"
+    r"svensk författningssamling\s*$|"
+    r"uradni list\s*$|"
+    r"dziennik ustaw\s*$|"
+    r"monitorul oficial\s*$|"
+    r"εφημερίδα της κυβερνήσεως\s*$|"
+    r"resmi gazete\s*$|"
+    r"iris oifigiúil\s*$|"
+    r"latvijas vēstnesis\s*$|"
+    r"valstybės žinios\s*$|"
+    r"官報\s*$|"
+    r"国务院公报\s*$|"
+    r"관보\s*$|"
+    r"ราชกิจจานุเบกษา\s*$|"
+    r"(?:เล่ม|เลม)\s*[๐-๙0-9].*ราชกิจจานุเบกษา.*|"
+    r"اطلاق نسخة جديدة من الميزان\s*$|"
+    r"\[\d+/\d{4}(?:\s+wef\s+[\d/]+)?\]\s*$|"
+    r"\[\d{1,2}(?:st|nd|rd|th)\s+[a-z]+\s+\d{4}\]\s+.+\s+\d{1,4}\s*$|"
+    r"\[\d{1,2}(?:st|nd|rd|th)\s+[a-z]+,?\s+\d{4}\]\s*$|"
+    r"(?:18|19|20)\d{2}\s*$|"
+    r"gazette\.?\s*$|"
+    r"cap\.\s*\d+(?:\.\d+)*\s*$|"
+    r".+\scap\.?\s*[\d.]+\s+section\s+\d+\s*$|"
+    r"diario oficial\s*$|"
+    r"diário oficial(?: da união)?\s*$|"
+    r"gaceta oficial(?: de la república)?\s*$|"
+    r"registro oficial\s*$|"
+    r"sbírka zákonů\s*$|"
+    r"zbierka z[^\n]{0,40}\s*$|"
+    r"magyar közlöny\s*$|"
+    r"narodne novine\s*$|"
+    r"službeni glasnik\s*$|"
+    r"службени гласник\s*$|"
+    r"държавен вестник\s*$|"
+    r"monitorul oficial(?: al româniei)?\s*$|"
+    r"norsk lovtidend\s*$|"
+    r"suomen säädöskokoelma\s*$|"
+    r"finlands författningssamling\s*$|"
+    r"riigi teataja\s*$|"
+    r"российская газета\s*$|"
+    r"(?:the )?kenya gazette\s*$|"
+    r"federal negar[ie]t gazett?e\s*$|"
+    r"gazette officielle\s*$|"
+    r"amtsblatt(?: der europäischen union)?\s*$|"
+    r"official journal of the european union\s*$|"
+    r"journal officiel de l'union européenne\s*$|"
+    r"gazzetta ufficiale dell'unione europea\s*$|"
+    r"الجريدة الرسمية\b.*|"
+    r"ваш броузер застарів\b.*|"
+    r"your browser is (?:out of date|outdated|obsolete)\b.*|"
+    r"all rights reserved\b.*|"
+    r"subscribe to\s+(?:our\s+)?(?:newsletter|mailing(?:\s+list)?|updates|feed)\b.*|"
+    r"(?:we use|this (?:site|website) uses)\s+cookies\b.*|"
+    r".{0,80}використовуємо cookies\b.*|"
+    r".{0,80}використання cookies\b.*|"
+    r"продовжуючи відвідування сайту\b.*|"
+    r"al meezan\b.*|"
+    r"الميزان\b.*|"
+    r".{0,40}وزارة العدل(?: و الشؤون القانونية)?\s*$|"
+    r"التشريعات\b.*|"
+    r"page not found\b.*|"
+    r"(?:error\s+)?404(?:\s+not found)?\b.*|"
+    r"access denied\s*$|"
+    r"forbidden\s*$|"
+    r"public notification\s*$|"
+    r"[^\n]{0,40}@mjla\b.*|"
+    r".{0,40}gaceta oficial(?: digital)?\b.*|"
+    r"paragraph\s*$|"
+    r"[^\n]{0,60}slov-lex\s*$|"
+    r"(?:crown\s+)?copyright\s*(?:©\s*)?\d{4}\.?\s*$|"
+    r"copying\s*/\s*unauthori[sz]ed distribution strictly prohibited\.?\s*$|"
+    r"(?:revision|consolidation) date\s*:.*|"
+    r"showing the law as at\s+\d.*|"
+    r"this is a revised edition of the law\b.*|"
+    r"printed under authority by\s*$|"
+    r"(?:the )?regional law revision centre\b.*|"
+    r"continued on next page\b.*|"
+    r"back to (?:page one|the top|top)\s*$|"
+    r"page\s*:\s*\d+\s+date\s*:.*|"
+    r"bwpageid\s*::.*|"
+    r"bwservice\s*::.*|"
+    r".*ron_book\b.*|"
+    r"\d+\s+service\s+\d+\s*$|"
+    r"(?:pdf|word|audio)\s+download\s*$|"
+    r"login with (?:facebook|google|apple|twitter|email)\b.*|"
+    r"(?:view|print|e-?mail)\s*$|"
+    r"last updated(?:\s+on)?\s+\d.*|"
+    r"speakers office\s*$|"
+    r"fsm congress\s*$|"
+    r".*almeezan\b.*|"
+    r"add new section\s*$|"
+    r"section name\s*$|"
+    r".*hijripage\b.*|"
+    r"search in articles\s*$|"
+    r"privacy statement\s*$|"
+    r"terms of use\s*$|"
+    r"rate this website\s*$|"
+    r"feedback via reach\s*$|"
+    r"singapore statutes online\b.*|"
+    r".*reprint is authorised by\b.*|"
+    r"công báo\s*/\s*số\b.*|"
+    r"thời gian ký\s*:.*|"
+    r"lex\.?uz\b.*|"
+    r"\[?(?:окоз|тсз|спит)\s*:.*|"
+    r"\d+(?:\.\d{2}){3,}.*[\u0400-\u04FF].*|"
+    r"issue\s*:\s*\d+\s*,\s*amendment\s*:\s*\d+\b.*|"
+    r"presidential comm\.?\s*no\b.*|"
+    r"(?:january|february|march|april|may|june|july|august|september|october|november|december)\s+\d{1,2},?\s+\d{4}(?:\s+[a-z])?\s*$|"
+    r"(?-i:\d{1,4}\s+[Cc][Aa][Pp]\.\s*\d+\.\d+\b(?!.*\b(?!etc\b)[a-z]{3,}\b).*$)|"
+    r"(?-i:(?!.*\b(?!etc\b)[a-z]{3,}\b).{0,90}\b[Cc][Aa][Pp]\.\s*\d+\.\d+(?:\.\d+)*\s+\d{1,4}\s*$)|"
+    r"(?-i:\d{1,4}\s+[Cc][Aa][Pp]\.\s*\d+\s+(?!.*\b[a-z]{3,}\b).+$)|"
+    r"(?-i:(?!.*\b[a-z]{3,}\b).{0,90}\b[Cc][Aa][Pp]\.\s*\d+\s+\d{1,4}\s*$)|"
+    r"(?-i:\d{1,4}\s+[Cc]hap\.\s*\d+(?::\d+)?\b(?!.*\b[a-z]{3,}\b).*$)|"
+    r"(?-i:\d{1,4}\s+(?:[A-Z][A-Za-z]+(?:\s+|$)){3,12}(?:19|20)\d{2}\s*$)|"
+    r"(?-i:(?:[A-Z][A-Za-z]+(?:\s+|$)){3,12}(?:19|20)\d{2}\s+\d{1,4}\s*$)|"
+    r"constituci[oó]n pol[ií]tica del per[uú]\s+\d+\s*$|"
+    r"\d{1,4}\s+edici[oó]n del congreso\b.*|"
+    r"nr\.\s*\d+\s*\].*\[.*|"
+    r"st\.?\s*christopher and nevis\s*$|"
+    r"official gazette\s+nr\.\s*\d[\d\s/.-]*(?:\s+of\s+[\d/.-]+)?\s*$|"
+    r"www\.\S+(?:\s+(?!(?:for|under|and|the|is|of)\b)[A-Za-z][\w.-]{1,24}){1,2}\s*$|"
+    r".*laws\.africa\b.*|"
+    r".*share widely and freely.*|"
+    r".*no copyright on the legislative content.*|"
+    r"(?-i:^(?:Malawi|Zambia|Kenya|Uganda|Ghana|Namibia|Botswana|Lesotho|Eswatini|Rwanda|Tanzania|Nigeria|Zimbabwe|Mauritius|Seychelles|Liberia|Gambia)\s+.{0,80}\(Chapter\s+\d+\)\s*$)|"
+    r"(?-i:^Act\s+\d+\s+(?:[A-Z][a-z]+\s+){1,6}(?:19|20)\d{2}\s*$)|"
+    r"issue\s*:?\s*\d+(?:\.\d+)?\s+page\s+\d+\s+of\s+\d+\b.*|"
+    r"issue\s*:\s*\d+(?:\.\d+)?\s+\d+\s+\d{1,2}\s+[a-z]+\s+\d{4}\s*$|"
+    r".*edition officielle mise [aà] jour.*|"
+    r"code general des impots\s+\d{4}\s*$|"
+    r"\d{1,2}\.\d{1,2}\.\d{4}\s*-\s*\d{1,2}\.\d{1,2}\.\d{4}\s*$|"
+    r"(?!.*δημοσιευ)(?!.*\bστην\b)(?=.*εφημερ.{0,12}κυβερν)(?=.*(?:τευξ|τεύχ|\(\s*τευ)).{0,140}$|"
+    r"(?:\d{1,4}\s+)?επ[ιί]σημη\s+εφημερ[ιί]δ[αά]\b.*|"
+    r"sistema integrado de gest[aã]o de finan[cç]as p[uú]blicas\s*\(sigfip\)\s*\d+\s*/\s*\d+\s*$|"
+    r"editado por\s*:.*\beditado em\s*:.*|"
+    r"issue\s+\d{1,4}\s*$|"
+    r"\d{1,4}\s*\|\s*page\s*$|"
+    r"page\s*\|\s*\d{1,4}\s*$|"
+    r"\{\{[^}\n]*\}\}\s*$|"
+    r"lap tetej[eé]re\s*$|"
+    r"megnyitottak\s*$|"
+    r"jogszab[aá]lykeres[oő]\s*$|"
+    r".*slu[zž]beni glasnik\b.{0,50}stranica\s+\d+\s*$|"
+    r".*\(unknown\)/ron\b.*|"
+    r"\[the next page is\s+[\d,]+\s*\]\s*$|"
+    r"service\s+\d+\s+[\d,]+\s*$|"
+    r"\[act\s+\d+\s+of\s+\d{4}\s+wef\s+[\d/]+\]\s*$|"
+    r"(?:i{1,3}|iv|vi{0,3}|ix|xi{0,3})\s+s[eé]rie\s*-\s*n[uú]mero\s+\d+(?:\s+(?:[a-zç]+-feira|s[aá]bado|domingo),?\s*\d{1,2}\s+de\s*[a-zç]+\s+de\s+\d{4})?\s*$|"
+    r"(?:i{1,3}|iv|vi{0,3}|ix|xi{0,3})\s*-?\s*s[eé]rie\b.*\d.*|"
+    r"(?:i{1,3}|iv|vi{0,3}|ix|xi{0,3})s[eé]rie\b.*\d.*|"
+    r"\d+\s+(?:[a-zç]+-feira|s[aá]bado|domingo),?\s+\d{1,2}\s+de\s+[a-zç]+\s+de\s+\d{4}(?:\s+p[aá]gina\s+\d+)?\s*$|"
+    r"s[eé]rie\s+[ivx]+\s*,\s*nr\.\s*\d+\b.{0,80}p[aá]gina\s+\d+\s*$|"
+    r"(?:[a-zç]+-feira|s[aá]bado|domingo),?\s+\d{1,2}\s+de\s+[a-zç]+\s+de\s+\d{4}\s+s[eé]rie\s+[ivx]+\s*,\s*nr\.\s*\d+\s*$|"
+    r"\d+\s*[\(\)]+\s*مذكرة تفسيرية\b.*|"
+    r"-\s*\d+\s*-\s*\).*$|"
+    r".*constituteproject\.org.*|"
+    r"pdf generated\s*:.*|"
+    r"[a-z][a-z]+(?:\s+[a-z][a-z]+){0,3}\s+(?:19|20)\d{2}\s+page\s+\d+\s*$|"
+    r"الصفحة\s*\.?\s*[0-9٠-٩]+\s*$|"
+    r"\[state/territory\]\s*$|"
+    r"direction g[eé]n[eé]rale adjointe des imp[oô]ts\s*$|"
+    r"et des domaines\s*$|"
+    r"rio:\s*\d+\s*$|"
+    r"#+\s*journal officiel\b.*|"
+    r"journal officiel\s*-\s*banque des?\s*donn[eé]es juridiques\b.*|"
+    r"(?!.*\b(?:publie|publi[eé]|shall|entre)\b)journal officiel (?:de la r[eé]publique|du faso)\b.{0,50}$|"
+    r"\[(?:\.{3}|…)\]\s*$|"
+    r"bsd:\s*\d+\s*$|"
+    r"\d{1,2}\.?\s+(?:gennaio|febbraio|marzo|aprile|maggio|giugno|luglio|agosto|settembre|ottobre|novembre|dicembre)\s*$|"
+    r"(?-i:(?:[A-Z][A-Za-z]+\s+){1,12}(?:Act|Law|Code),?\s+(?:19|20)\d{2}(?:\s+(?:19|20)\d{2})?\s+nr\.\s*\d+\s+[A-Z]\s+\d+\s*$)|"
+    r"(?-i:^[A-Z]\s+\d{1,4}\s+(?:19|20)\d{2}\s+nr\.\s*\d+\s+(?:[A-Z][A-Za-z]+\s+){1,12}(?:Act|Law|Code),?\s+(?:19|20)\d{2}\s*$)|"
+    r"printed on the orders? of government\s*\.?\s*$|"
+    r".*(?<![A-Za-z])(?:printed|thinted)\b.{0,80}government printing\b.*|"
+    r"to be purchased at the govt\.?\s*publications bureau\b.*|"
+    r"b\.?\s*l\.?\s*r\.?\s*o\.?\s*\d+\s*/\s*\d{4}\s*$|"
+    r"pages authorised\s*$|"
+    r"(?:current\s+)?authorised pages\s*$|"
+    r"\(inclusive\)\s*by\s+lro\.?\s*$|"
+    r"(?-i:(?:[A-Z][a-z]+(?:\s+|$)){1,8}(?:Malawi|Zambia|Kenya|Uganda|Ghana|Namibia|Botswana|Lesotho|Eswatini|Rwanda|Tanzania|Nigeria|Zimbabwe|Mauritius|Seychelles|Liberia|Gambia)\s*$)|"
+    r"code\s+\S+(?:\s+\S+){0,6}\s+\d{1,3}/\d{2,3}\s*$|"
+    r"index\s*$|"
+    r"ministry/program(?:me)?/sub(?:head|program(?:me)?)\s+page\s*$|"
+    r"page\s+\d{1,3}\s*/\s*\d{1,3}\s*$|"
+    r"\[?\s*printed by authority of the\s*$|"
+    r"printed in [a-z][a-z .'-]{0,40}by the government printer\s*$|"
+    r"[\w.+-]+@[\w.-]+\.[a-z]{2,}\s+www\.\S+\s*$|"
+    r"secr[eé]tariat g[eé]n[eé]ral du gouvernement\s+www\.\S+\s*$|"
+    r"site:\s*(?:https?://|www\.)\S+\s*$|"
+    r"justice sector support program\s*\(jssp\).*|"
+    r"serial number:\s*\d+\b.*|"
+    r"copyright government of [a-z]+(?:\s+[a-z]+){0,3}\s*$|"
+    r"this page was intentionally left blank\.?\s*$|"
+    r"this is page \d+ of \d+\s+pages? of the above table\.?\s*$|"
+    r"new provisions(?: in the schedule)? are printed in italics\.?\s*$|"
+    r"go to top page(?: next chapter)?\s*$|"
+    r"(?:\d{4}\s+)?parliamentary series\s+(?:nr\.|no\.?)\s*\d+\s*$|"
+    r"try reloading the page or downloading the pdf\.?\s*$|"
+    r"reload page\s*$|"
+    r"uploaded by:\s*https?://\S+\s*$|"
+    r"t[eé]l[eé]charg[eé] sur www\.\S+\s*$|"
+    r"ibirimo/summary/sommaire\b.*|"
+    r"website:\s*(?:https?://|www\.)\S+\s*$|"
+    r"www\.\S+\s+[\w.+-]+@[\w.-]+\s*$|"
+    r"gazette order page\.?\s*$|"
+    r"(?:lexis finder|esilec profesional)\s*-\s*www\.\S+\s*$|"
+    r"official gazette\s+(?:nr\.|no\.?)\s*(?:special(?:\s+bis)?|\d+\s*bis)\s+of\b.*|"
+    r"s[eé]rie\s+[ivxlcdm]+\s*,\s*nr\.\s*\S+(?:\s+[A-Za-z0-9]+)?\s*$|"
+    r"unofficial translat(?:ed|ion)\b.*|"
+    r"\(?\d[\d\s().-]{6,}\)?\s*\|\s*(?:https?://|www\.)\S+\s*$|"
+    r"volume:\s*\d+\s+issue no:\s*\d+\s+government gazette\s*$|"
+    r"tonga government gazette supplement\s*$|"
+    r"ministry of legal affairs\s+www\.\S+\s*$|"
+    r"\d+\s+www\.\S+\s*$|"
+    r"www\.\S+\s+\d+\s*/\s*\d+\s*$|"
+    r"www\.\S+\s+(?:(?!for\b|is\b|shall\b|the\b)[a-z][a-z .'-]{0,50})$|"
+    r".*/type/page>{2,}.*|"
+    r"subject\.\s*reference\.\s*page\.?\s*$|"
+    r"name reference page no\.?\s*$|"
+    r"sl\s*#\s*law\s*#\s*legislation commencement gazette\s*$|"
+    r"gn\s*=\s*gazette notice\b.*|"
+    r"de blank page\b.*|"
+    r"printed and published by the ministry of justice\b.*|"
+    r"rarotonga,\s*cook islands:\s*printed under the authority\b.*|"
+    r"e-?mail\s*:\s*\S+@\S+.*(?:site web|www\.)\S+.*|"
+    r"διεύθυνση στο διαδίκτυο\s*\(url\)\s*:\s*https?://\S+.*|"
+    r"spletna stran:\s*www\.\S+\s*$|"
+    r"copyright\s*$|"
+    r"copyright and designs act\s+\d{4}\s*$|"
+    r"copyright act\s+\d{4}\s*$|"
+    r"powered by tcpdf\b.*|"
+    r"pour l'acquisition de votre abonnement\b.*|"
+    r"a\s*bonnement au journal officiel\b.*|"
+    r"[eé]dit[eé] par la direction de l'[eé]dition du journal officiel\b.*|"
+    r"\[the inclusion of this page is authori[sz]ed by\b.*|"
+    r"ins\s*=\s*inserted\b.*|"
+    r"[a-z]{2,8}\s*=\s*gazette\b.*|"
+    r"site web\s*:\s*www\.\S+\s*$|"
+    r"web\s*sites?\s*:?\s*-?\s*www\.\S+\s*$|"
+    r".*www\.documents\.gov\.lk\s*$|"
+    r"τηλ\.?:?\s*[\d\s,]+φαξ:?\s*[\d\s]+\s*-\s*www\.\S+\s*$|"
+    r"das dokument ist einsehbar unter:\s*www\.\S+\s*$|"
+    r"sujet articles page\s*$|"
+    r"language is printed on uneven numbered pages\.?\s*$|"
+    r".*www\.nbs\.sk\.?\s*$|"
+    r"\d{2}-\d{4,6}\s+\d{1,3}/\d{1,3}\s*$|"
+    r"\d{1,3}/\d{1,3}\s+\d{2}-\d{4,6}\s*$|"
+    r"[as]/(?:res|prst)/\d+\s*\(\d{4}\)\s*$|"
+    r"ab\s+\d{4},\s*nr\.\s*\d+\s*$|"
+    r"grondslag\s*:\s*[.\-–\s]*$|"
+    r"رقم الهاتف\s*:.*|"
+    r"\+[\u0600-\u06FF]{1,2}\s*$|"
+    r"(?-i:(?!.*\b(?:est|sont|doit|shall)\b)(?!.*\b[a-z]{4,}\b).*\bImprimerie\s+[A-Z].*$)|"
+    r"(?-i:(?!.*\b(?:shall|is|are|means|under|must)\b).{8,120}\(Chapter\s+\d+(?::\d+)?\)\s+[A-Z][a-z]+\s*$)|"
+    r"(?-i:(?!.*\b(?:ACT|LAW|CODE|DECREE|ORDINANCE|CHAPTER|ARTICLE|SECTION|TITLE|PART|SCHEDULE|GENERAL|PROVISIONS|SHORT|INTERPRETATION|PRELIMINARY|AMENDMENT|REPEAL|COMMENCEMENT|DEFINITIONS|REGULATIONS|RULES|ORDER|APPENDIX)\b)(?:[A-ZÁÉÍÓÚÜÑ]{2,}(?:\s+|$)){4,10}\d{1,3}\s*$)|"
+    r"(?-i:(?!.*\b(?:ACT|LAW|CODE|DECREE|ORDINANCE|CHAPTER|ARTICLE|SECTION|TITLE|PART|SCHEDULE|GENERAL|PROVISIONS|SHORT|INTERPRETATION|PRELIMINARY|AMENDMENT|REPEAL|COMMENCEMENT|DEFINITIONS|REGULATIONS|RULES|ORDER|APPENDIX)\b)\d{3,4}\s+(?:[A-ZÁÉÍÓÚÜÑ]{3,}(?:\s+|$)){1,3}\s*$)|"
+    r"\[\d{1,4}\]?\s*$|"
+    r"หน.?า\s+[0-9๐-๙]+\s*$|"
+    r"(?:home|blog|contact us|cookie|accueil|startseite|"
+    r"página inicial|página principal|επικοινωνία|αρχική)\s*$"
+    r")"
+)
+_CHROME_INLINE_RE = re.compile(
+    r"(?i)skip to (?:main )?content|all rights reserved|click here|"
+    r"légimonaco"
+)
+_JA_ART_RE = re.compile(r"第\s*[0-9一二三四五六七八九十百]+\s*[条條]")
+_CIRCLED_ART_RE = re.compile(r"[①-⑳⑴-⒇❶-❿⓫-⓴]")
+_CJK_ENUM_RE = re.compile(r"(?m)^[ \t]*[一二三四五六七八九十百]+、")
+_CJK_PAREN_RE = re.compile(r"(?m)^[ \t]*[（(][一二三四五六七八九十百]+[）)]")
+_CJK_DIGIT_ENUM_RE = re.compile(r"(?m)^[ \t]*[0-9０-９]+、")
+_KO_GA_RE = re.compile(r"(?m)^[ \t]*[가나다라마바사아자차카타파하]\.")
+_JA_KATA_ENUM_RE = re.compile(r"(?m)^[ \t]*[アイウエオカキクケコ]、")
+_HANGUL_GA = "가나다라마바사아자차카타파하"
+_KATA_ENUM = "アイウエオカキクケコ"
+_AR_ABJAD_INDEX = {
+    "أ": "1", "ا": "1", "ب": "2", "ج": "3", "د": "4", "ه": "5",
+    "و": "6", "ز": "7", "ح": "8", "ط": "9", "ي": "10",
+}
+_HE_ALEF = "אבגדהוזחטי"
+_TH_KO = "กขคงจฉชซฌญ"
+_AR_ABJAD_RE = re.compile(r"(?m)^[ \t]*[(\[]?[أابجدهوزحطي][)\]]?\s*[-.)]")
+_HE_ALEF_RE = re.compile(r"(?m)^[ \t]*[אבגדהוזחטי]\.")
+_HE_PEREK_RE = re.compile(r"(?m)^[ \t]*פרק\s+[א-ת]{1,3}['׳]?")
+_HE_SIMAN_RE = re.compile(r"(?m)^[ \t]*סימן\s+[א-ת]{1,3}['׳]?")
+_HE_HELEK_RE = re.compile(r"(?m)^[ \t]*חלק\s+[א-ת]{1,3}['׳]?")
+_HE_TOS_RE = re.compile(
+    r"(?m)^[ \t]*תוספת\s+(?:ראשונה|שנייה|שניה|שלישית|רביעית|חמישית|שישית|[א-ת]['׳]?|[0-9]+)"
+)
+_HE_TAKANA_RE = re.compile(r"(?m)^[ \t]*תקנה\s+[0-9]+")
+_AR_ANNEX_RE = re.compile(r"(?m)^[ \t]*ملحق(?:\s*رقم)?\s*[0-9٠-٩()]+")
+_AR_BAB_RE = re.compile(
+    r"(?m)^[ \t]*الباب\s+(?:[0-9٠-٩]+|" + _AR_ORD_M + r"|" + _AR_ORD + r")"
+)
+_AR_FASL_RE = re.compile(
+    r"(?m)^[ \t]*الفصل\s+(?:[0-9٠-٩]+|" + _AR_ORD_M + r"|" + _AR_ORD + r")"
+)
+_AR_KITAB_RE = re.compile(
+    r"(?m)^[ \t]*الكتاب\s+(?:[0-9٠-٩]+|" + _AR_ORD_M + r"|" + _AR_ORD + r")"
+)
+_AR_FARA_RE = re.compile(
+    r"(?m)^[ \t]*الفرع\s+(?:[0-9٠-٩]+|" + _AR_ORD_M + r"|" + _AR_ORD + r")"
 )
-_JA_ART_RE = re.compile(
-    r"(?:(?<=\n)|^)[ 　]*(第[0-9一二三四五六七八九十百]+条)"
+_FA_BAND_RE = re.compile(r"بند\s*[0-9۰-۹]+")
+_CJK_ZHANG_RE = re.compile(r"第\s*[一二三四五六七八九十百千万零〇两0-9]+\s*章")
+_KO_JANG_RE = re.compile(r"제\s*[0-9]+\s*장")
+_TA_ART_RE = re.compile(r"பிரிவு\s*[0-9௦-௯]+")
+_TE_ART_RE = re.compile(r"ప్రకరణ(?:ము)?\s*[0-9౦-౯]+")
+_KN_ART_RE = re.compile(r"ಪ್ರಕರಣ\s*[0-9೦-೯]+")
+_GU_ART_RE = re.compile(r"કલમ\s*[0-9૦-૯]+")
+_PA_ART_RE = re.compile(r"ਧਾਰਾ\s*[0-9੦-੯]+")
+_ML_ART_RE = re.compile(r"വകുപ്പ്\s*[0-9൦-൯]+")
+_CJK_BIAN_RE = re.compile(r"第\s*[一二三四五六七八九十百千万零〇两0-9]+\s*[编編]")
+_KO_PYEON_RE = re.compile(r"제\s*[0-9]+\s*편")
+_TH_LAK_RE = re.compile(r"(?m)^[ \t]*ลักษณะ\s*[0-9๐-๙]+")
+_KM_CHAP_RE = re.compile(r"ជំពូក\s*[0-9០-៩]+")
+_LO_PART_RE = re.compile(r"ພາກ\s*[0-9໐-໙]+")
+_MY_CHAP_RE = re.compile(r"အခန်း\s*[0-9၀-၉]+")
+_KA_CHAP_RE = re.compile(r"თავი\s+[IVXLCDM0-9]+")
+_HY_CHAP_RE = re.compile(r"Գլուխ\s+[IVXLCDM0-9]+", re.IGNORECASE)
+_AM_CHAP_RE = re.compile(r"ምዕራፍ\s*[0-9፩-፻]+")
+_HI_CHAP_RE = re.compile(r"अध्याय\s*[0-9०-९]+")
+_BN_CHAP_RE = re.compile(r"অধ্যায়\s*[0-9০-৯]+")
+_UR_CHAP_RE = re.compile(r"باب\s*[0-9۰-۹]+")
+_FA_FASL_RE = re.compile(r"فصل\s*[0-9۰-۹]+")
+_NE_CHAP_RE = re.compile(r"परिच्छेद\s*[0-9०-९]+")
+_CJK_JIE_RE = re.compile(r"第\s*[一二三四五六七八九十百千万零〇两0-9]+\s*[节節]")
+_KO_JEOL_RE = re.compile(r"제\s*[0-9]+\s*절")
+_TH_TON_RE = re.compile(r"(?m)^[ \t]*ตอน\s*[0-9๐-๙]+")
+_SR_PART_RE = re.compile(r"(?:Одељак|ОДЕЉАК)\s+[IVXLCDM0-9]+", re.IGNORECASE)
+_RU_TITLE_RE = re.compile(
+    r"(?:Раздел|РАЗДЕЛ|Розділ|РОЗДІЛ|Раздзел|РАЗДЗЕЛ)\s+[IVXLCDM0-9]+",
+    re.IGNORECASE,
+)
+_RU_CHAP_RE = re.compile(r"(?:Глава|ГЛАВА)\s+[IVXLCDM0-9]+", re.IGNORECASE)
+_TH_KO_RE = re.compile(r"(?m)^[ \t]*[กขคงจฉชซฌญ]\.")
+_HI_DIGIT_ENUM_RE = re.compile(r"(?m)^[ \t]*[०-९]+\s*[.।]")
+_BN_DIGIT_ENUM_RE = re.compile(r"(?m)^[ \t]*[০-৯]+\s*[.।]")
+_CYR_AB = "абвгдежзийк"
+_EL_AB = "αβγδεζηθικ"
+_KA_AB = "აბგდევზთიკლ"
+_HY_AB = "աբգդեզէըթժ"
+_CYR_AB_RE = re.compile(r"(?im)^[ \t]*[абвгдежзийк]\s*[).]")
+_EL_AB_RE = re.compile(r"(?im)^[ \t]*[αβγδεζηθικ]\s*[).]")
+_KA_AB_RE = re.compile(r"(?m)^[ \t]*[აბგდევზთიკლ]\s*[).]")
+_HY_AB_RE = re.compile(r"(?m)^[ \t]*[աբգդեզէըթժ]\s*[).]")
+_MARK_AFTER = r"(?:\s+|(?=[^\x00-\x7f]))"
+_LATIN_LETTER_RE = re.compile(
+    r"(?m)^[ \t]*(?:\(\s*(?P<paren>[a-z])\s*\)|(?P<bare>[a-z])\)|"
+    r"(?P<roman>viii|iii|vii|ii|iv|ix|vi|i|v|x)\.)"
+    + _MARK_AFTER
+)
+_BULLET_RE = re.compile(r"(?m)^[ \t]*[•·●‣⁃*#]\s+")
+_DASH_NUM_RE = re.compile(r"(?m)^[ \t]*-\s*(?P<bn>[0-9]{1,3})\s+(?=[^\W\d_])")
+_LATIN_NUM_LIST_RE = re.compile(
+    r"(?m)^[ \t]*(?:"
+    r"\(\s*(?P<nparen>[0-9]{1,3})\s*\)|"
+    r"(?P<nclose>[0-9]{1,3})\)|"
+    r"(?P<nord>[0-9]{1,3})[º°o]|"
+    r"(?P<ndot>[0-9]{1,3})\.-|"
+    r"(?P<ncolon>[0-9]{1,3}):|"
+    r"(?P<ndash>[0-9]{1,3})-|"
+    r"(?P<dbl>([a-z])\2)\)"
+    r")"
+    + _MARK_AFTER
+)
+_ROMAN_LOWER = {
+    "i": "1", "ii": "2", "iii": "3", "iv": "4", "x": "10",
+    "v": "5", "vi": "6", "vii": "7", "viii": "8", "ix": "9",
+}
+_JA_KOU_RE = re.compile(r"第[0-9一二三四五六七八九十百]+項")
+_ZH_KUAN_RE = re.compile(r"第[一二三四五六七八九十百千万零〇两0-9]+款")
+_KO_ART_RE = re.compile(r"제\s*[0-9]+\s*조")
+_KO_HANG_RE = re.compile(r"제\s*[0-9]+\s*항")
+_KO_HO_RE = re.compile(r"제\s*[0-9]+\s*호")
+_TH_PARA_RE = re.compile(r"วรรค\s*[0-9๐-๙]+")
+_TH_KHO_RE = re.compile(r"(?m)^[ \t]*ข้อ\s*[0-9๐-๙]+")
+_TH_HUAT_RE = re.compile(r"(?m)^[ \t]*หมวด\s*[0-9๐-๙]+")
+_FA_TAB_RE = re.compile(r"تبصره\s*[0-9۰-۹]+")
+_HE_PARA_RE = re.compile(r"פסקה\s*[0-9]+")
+_AR_PARA_RE = re.compile(r"الفقرة\s*[0-9٠-٩]+")
+_AR_QARAR_RE = re.compile(r"قرار(?:\s*رقم)?\s*[0-9٠-٩]+")
+_AR_DECREE_RE = re.compile(r"(?:مرسوم|أمر)(?:\s*رقم)?\s*[0-9٠-٩]+")
+_RU_INST_RE = re.compile(r"(?:Указ|Постановление|Приказ)\s+[0-9]+", re.IGNORECASE)
+_KO_RANGE_RE = re.compile(
+    r"제\s*[0-9]+\s*조\s*부터\s*제\s*[0-9]+\s*조(?:까지)?"
+)
+_HE_ART_RE = re.compile(
+    r"(?:סעיף\s*(?:[0-9]+|(?!קטן)[א-ת]{1,3}['׳]?)|\.\s*[0-9]+(?=[\u0590-\u05FF]))"
+)
+_HE_KATAN_RE = re.compile(r"סעיף\s+קטן\s*\(?\s*[א-ת]'?\)?")
+_TH_ART_RE = re.compile(r"มาตรา\s*[0-9๐-๙]+")
+_HI_ART_RE = re.compile(r"(?:धारा|ধারা)\s*[0-9০-৯]+")
+_RU_ART_RE = re.compile(r"(?:Статья|СТАТЬЯ|Стаття|СТАТТЯ)\s+[0-9]+(?:-[0-9]+)?", re.IGNORECASE)
+_KA_ART_RE = re.compile(r"მუხლი\s*[0-9]+")
+_HY_ART_RE = re.compile(r"Հոդված\s*[0-9]+", re.IGNORECASE)
+_AM_ART_RE = re.compile(r"አንቀጽ\s*[0-9፩-፻]+")
+_BN_ART_RE = re.compile(r"ধারা\s*[0-9০-৯]+")
+_LO_ART_RE = re.compile(r"ມາດຕາ\s*[0-9໐-໙]+")
+_KM_ART_RE = re.compile(r"មាត្រា\s*[0-9០-៩]+")
+_MY_ART_RE = re.compile(r"ပုဒ်မ\s*[0-9၀-၉]+")
+_UZ_ART_RE = re.compile(r"[0-9]+\s*-\s*(?:модда|modda)", re.IGNORECASE)
+_MN_ART_RE = re.compile(r"[0-9]+\s*(?:дүгээр|дугаар)\s*зүйл", re.IGNORECASE)
+_KK_ART_RE = re.compile(r"[0-9]+\s*-?\s*бап", re.IGNORECASE)
+_NE_ART_RE = re.compile(r"दफा\s*[0-9०-९]+")
+_TI_ART_RE = re.compile(r"ዓንቀጽ\s*[0-9፩-፻]+")
+_BO_ART_RE = re.compile(r"དོན་ཚན་\s*[0-9༠-༩]+")
+_UG_ART_RE = re.compile(r"ماددا\s*[0-9۰-۹]+")
+_AR_POINT_RE = re.compile(r"(?m)^[ \t]*(?:أولا|ثانيا|ثالثا|رابعا|خامسا)\s*[:/]")
+_AR_POINT_NUM = (("أولا", "1"), ("ثانيا", "2"), ("ثالثا", "3"), ("رابعا", "4"), ("خامسا", "5"))
+_SI_ART_RE = re.compile(r"වගන්තිය\s*[0-9෦-෯]+")
+_UR_ART_RE = re.compile(r"دفعہ\s*[0-9۰-۹]+")
+_KY_ART_RE = re.compile(r"[0-9]+\s*-?\s*берене", re.IGNORECASE)
+_BE_ART_RE = re.compile(r"Артыкул\s*[0-9]+", re.IGNORECASE)
+
+# "A R T Í C U L O 86" / "C A P I T U L O I" → ARTÍCULO 86 / CAPITULO I
+_SPACED_KEYWORD_RE = re.compile(
+    r"(?iu)\b((?:[A-ZÁÉÍÓÚÜÑÀÈÌÒÙÂÊÎÔÛÄËÏÖÜÃÕÇ]\s+){3,}"
+    r"[A-ZÁÉÍÓÚÜÑÀÈÌÒÙÂÊÎÔÛÄËÏÖÜÃÕÇ])\b"
+    r"(?=\s*[.:\-–—]?\s*[0-9IVXLCDM])"
+)
+
+
+def _squeeze_spaced_keyword(match: re.Match[str]) -> str:
+    return re.sub(r"\s+", "", match.group(1))
+
+
+_ZW_RE = re.compile(
+    r"[\ufeff\u200b\u200c\u200d\u00ad\u2060\u200e\u200f\u202a-\u202e\u2066-\u2069]"
+)
+# Tashkeel, niqqud, Latin combining. Keep Thai/Lao/Khmer/Myanmar/Indic Mn.
+_STRIP_MARKS_RE = re.compile(
+    "["
+    "\u0300-\u036f"
+    "\u0483-\u0489"
+    "\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7"
+    "\u0610-\u061a\u064b-\u065f\u0670\u06d6-\u06ed"
+    "\u08d3-\u08e1\u08e3-\u08ff"
+    "]"
+)
+_SCRIPT_CITE_TAIL_RE = re.compile(
+    r"(?i)^\s*(?:"
+    r"من\s*(?:الدستور|القانون|الأمر|المرسوم|القرار)|"
+    r"của\s+luật|"
+    r"של\s+(?:חוק|פקודה)"
+    r")"
+)
+
+# UTF-8 read as Latin-1: § (U+00C2 U+00A7) is §, é is é. Âmbito stays.
+_LATIN1_UTF8_RE = re.compile(r"[\u00c2\u00c3][\u0080-\u00bf]")
+
+
+def _repair_latin1_utf8(text: str) -> str:
+    if "\u00c2" not in text and "\u00c3" not in text:
+        return text
+
+    def repl(match: re.Match[str]) -> str:
+        try:
+            return match.group(0).encode("latin-1").decode("utf-8")
+        except UnicodeDecodeError:
+            return match.group(0)
+
+    return _LATIN1_UTF8_RE.sub(repl, text)
+
+
+# Script-tagged gazettes that still publish English Article/Section translations.
+_LATIN_FALLBACK_LANGS = frozenset(
+    {"ka", "km", "hy", "am", "lo", "my", "si", "th", "he", "ne", "fa"}
 )
 
 
@@ -121,15 +1004,185 @@ def strip_html(raw: str) -> str:
     return text.strip()
 
 
+_ROMAN_PAGE_RE = re.compile(
+    r"(?i)(?:i{1,3}|iv|vi{0,3}|ix|xi{0,3}|xiv|xv)$"
+)
+
+
+def _is_roman_page_line(line: str, nxt: str) -> bool:
+    """A lone i/ii/iii between blocks is a page stamp, not a list item."""
+    if _ROMAN_PAGE_RE.fullmatch(line.strip()) is None:
+        return False
+    nxt = nxt.strip()
+    if not nxt:
+        return True
+    return not (nxt[:1].islower() or nxt.startswith("("))
+
+
+def _is_page_num_line(line: str) -> bool:
+    token = line.strip()
+    if 1 <= len(token) <= 4 and all(unicodedata.category(ch) == "Nd" for ch in token):
+        return True
+    # "1/3" between paragraphs is page 1 of 3, not a section.
+    parts = token.split("/")
+    if len(parts) == 2 and all(part.isascii() and part.isdigit() for part in parts):
+        left, right = int(parts[0]), int(parts[1])
+        return 1 <= left <= right <= 30
+    return False
+
+
+def _is_facing_page_line(line: str) -> bool:
+    """'736 737' between blocks is a two-page spread, not a citation."""
+    parts = line.split()
+    if len(parts) != 2 or not all(part.isascii() and part.isdigit() for part in parts):
+        return False
+    left, right = int(parts[0]), int(parts[1])
+    return 100 <= left and right == left + 1 and right <= 9999
+
+
+_PAGE_OF_RE = re.compile(r"(?i)(\d{1,2})\s+of\s+(\d{1,2})")
+
+
+def _is_page_of_line(line: str) -> bool:
+    """'3 of 5' between blocks is a page count, not a citation."""
+    match = _PAGE_OF_RE.fullmatch(line.strip())
+    if match is None:
+        return False
+    left, right = int(match.group(1)), int(match.group(2))
+    return 1 <= left <= right <= 30
+
+
+def learned_patterns_path() -> Path:
+    override = os.environ.get("COUNTRY_LAWS_LEARNED_PATTERNS")
+    if override:
+        return Path(override)
+    return Path(__file__).resolve().parent / "data" / "learned_line_patterns.json"
+
+
+_LEARNED: tuple[float, re.Pattern[str] | None] | None = None
+
+
+def learned_line_pattern() -> re.Pattern[str] | None:
+    """Whole-line rules added by the normalize loop. Compiled once per file change."""
+    global _LEARNED
+    path = learned_patterns_path()
+    if not path.is_file():
+        return None
+    mtime = path.stat().st_mtime
+    if _LEARNED is not None and _LEARNED[0] == mtime:
+        return _LEARNED[1]
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        _LEARNED = (mtime, None)
+        return None
+    parts: list[str] = []
+    for item in payload.get("patterns") or []:
+        if not isinstance(item, str):
+            continue
+        try:
+            re.compile(item, re.IGNORECASE)
+        except re.error:
+            continue
+        parts.append(item)
+    compiled = re.compile("|".join(f"(?:{part})" for part in parts), re.IGNORECASE) if parts else None
+    _LEARNED = (mtime, compiled)
+    return compiled
+
+
+def strip_chrome_lines(text: str) -> str:
+    """Drop gazette-site chrome lines. Never invents replacement legal text."""
+    if not text:
+        return ""
+    raw_lines = text.splitlines()
+    multi = sum(1 for ln in raw_lines if ln.strip()) > 1
+    learned = learned_line_pattern()
+    kept = []
+    for idx, ln in enumerate(raw_lines):
+        stripped = ln.strip()
+        if not stripped:
+            continue
+        if _CHROME_LINE_RE.match(stripped) or _CHROME_INLINE_RE.search(ln):
+            continue
+        if learned is not None and learned.match(stripped):
+            continue
+        # A lone "2" or "10" is an article number. The same token inside a
+        # longer page is a page stamp.
+        if multi and (
+            _is_page_num_line(stripped)
+            or _is_facing_page_line(stripped)
+            or _is_page_of_line(stripped)
+        ):
+            continue
+        nxt = ""
+        for later in raw_lines[idx + 1 :]:
+            if later.strip():
+                nxt = later
+                break
+        if multi and _is_roman_page_line(stripped, nxt):
+            continue
+        kept.append(ln)
+    return "\n".join(kept).strip()
+
+
+_HYPHEN_BREAK_RE = re.compile(r"(?<=[^\W\d_])-[ \t]*\n+[ \t]*([^\W\d_])")
+
+
+def _join_hyphen_breaks(text: str) -> str:
+    """Join a hyphenated word split across lines. Leave a following capital header."""
+
+    def repl(match: re.Match[str]) -> str:
+        nxt = match.group(1)
+        if nxt.isupper():
+            return match.group(0)
+        return nxt
+
+    return _HYPHEN_BREAK_RE.sub(repl, text)
+
+
 def normalize_legal_text(value: Any) -> str:
     """NFKC + HTML strip. Keeps newlines so heading detection still works."""
     if value is None:
         return ""
-    text = unicodedata.normalize("NFKC", str(value))
+    text = unicodedata.normalize("NFKC", str(value)).replace("\x00", "")
+    if text.startswith("ÿþ") or text.startswith("þÿ"):
+        text = text[2:]
+    text = re.sub(r"[\x00-\x08\x0b\x0e-\x1f\x7f]", " ", text)
+    text = text.replace("\ufffd", " ")
+    text = re.sub(r"[\ue000-\uf8ff]", "", text)
+    text = _repair_latin1_utf8(text)
+    text = re.sub(r"\(cid:\d+\)", " ", text)
+    text = _ZW_RE.sub("", text).replace("ـ", "")
+    text = _STRIP_MARKS_RE.sub("", text)
+    text = re.sub(r"[\u2010-\u2015\u2212\ufe58\ufe63\uff0d]", "-", text)
+    text = re.sub(r"[\u00a0\u1680\u2000-\u200a\u202f\u205f\u3000]", " ", text)
+    text = text.replace("\u2028", "\n").replace("\u2029", "\n").replace("\f", "\n")
+    text = _join_hyphen_breaks(text)
+    text = _NUMERO_FOLD_RE.sub("nr. ", text)
+    text = re.sub(r"المادة\s*-\s*اختر\s*-\s*", "", text)
+    text = re.sub(r"(?m)^[ \t]*©+\s*", "", text)
+    text = re.sub(r"\b((?:19|20)\d{2}) \1\b", r"\1", text)
+    text = re.sub(r"(?<=[A-Za-z])!+(?=\d)", " ", text)
+    text = re.sub(r":!+", ":", text)
+    text = re.sub(r"(?m)!+\s*$", "", text)
+    text = _SPACED_KEYWORD_RE.sub(_squeeze_spaced_keyword, text)
+    text = re.sub(r"(?s)<!--.*?-->", " ", text)
     text = strip_html(text)
+    text = html_lib.unescape(text).replace("\xa0", " ")
+    text = re.sub(r"_{3,}", " ", text)
+    text = re.sub(r"\.{4,}", " ", text)
+    text = re.sub(r"(?m)^[ \t]*#{1,6}[ \t]+", "", text)
+    text = strip_chrome_lines(text)
     text = text.replace("\xa0", " ")
+    text = re.sub(r"~\$\S{0,16}", " ", text)
+    text = re.sub(r"\*\*([^*]{1,80})\*\*", r"\1", text)
+    text = re.sub(r"__([^_]{1,80})__", r"\1", text)
+    text = re.sub(r"'{3}([^']{1,80})'{3}", r"\1", text)
+    text = re.sub(r"^={2,6}\s*(.+?)\s*={2,6}\s*$", r"\1", text, flags=re.MULTILINE)
     text = re.sub(r"[ \t]+", " ", text)
     text = re.sub(r"\n[ \t]+", "\n", text)
+    text = re.sub(r"[ \t]+\n", "\n", text)
+    text = _join_hyphen_breaks(text)
     text = re.sub(r"\n{3,}", "\n\n", text)
     return text.strip()
 
@@ -147,6 +1200,8 @@ class StructureUnit:
     section_number: str = ""
     subsections: tuple[str, ...] = ()
     hierarchy_path: str = ""
+    char_start: int = 0
+    char_end: int = 0
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -161,6 +1216,8 @@ class StructureUnit:
             "section_number": self.section_number,
             "subsections": list(self.subsections),
             "hierarchy_path": self.hierarchy_path,
+            "char_start": self.char_start,
+            "char_end": self.char_end,
         }
 
 
@@ -190,116 +1247,880 @@ def _subsection_tokens(text: str) -> tuple[str, ...]:
     return tuple(seen)
 
 
-def _units_from_regex(
-    text: str, matches: list[re.Match[str]], *, kind: str, lang: str
-) -> list[StructureUnit]:
-    if len(matches) < MIN_SPLIT_HEADINGS:
-        return []
-    units: list[StructureUnit] = []
-    for i, match in enumerate(matches):
-        start = match.start()
-        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
-        chunk = text[start:end].strip()
-        if len(chunk) < 16:
-            continue
-        number = re.sub(r"\s+", "", match.group(0))
-        heading = re.sub(r"\s+", " ", chunk.split("\n", 1)[0])[:240]
-        units.append(
-            StructureUnit(
-                kind=kind,
-                number=number,
-                heading=heading,
-                body=chunk,
-                article_number=number,
-                hierarchy_path=heading,
-            )
-        )
-    return units if len(units) >= MIN_SPLIT_HEADINGS else []
+def check_exclusive_cover(text: str, units: list[StructureUnit]) -> bool:
+    """True iff units are contiguous, non-overlapping, and cover *text* exactly."""
+    if not units:
+        return not text
+    ordered = sorted(units, key=lambda u: u.char_start)
+    if ordered[0].char_start != 0 or ordered[-1].char_end != len(text):
+        return False
+    prev = 0
+    for unit in ordered:
+        if unit.char_start != prev or unit.char_end < unit.char_start:
+            return False
+        if text[unit.char_start : unit.char_end] != unit.body:
+            return False
+        prev = unit.char_end
+    return True
 
 
-def split_script_units(text: str, language: str) -> list[StructureUnit]:
-    """Article splits for scripts that must not use Latin TITLE/ARTICLE."""
+def _script_regex(language: str):
     from .profiles import iso_lang
 
     lang = iso_lang(language)
     if lang in {"zh", "zh-cn", "zh-tw"}:
-        prepared = re.sub(
-            r"(第[一二三四五六七八九十百千万零〇两0-9]+条(?:之[一二三四五六七八九十百0-9]+)?)",
-            r"\n\1",
-            text,
-        )
-        return _units_from_regex(prepared, list(_ZH_ART_RE.finditer(prepared)), kind="article", lang="zh")
-    if lang in {"ar", "fa"}:
-        prepared = re.sub(r"(المادة|مادة)", r"\n\1", text)
-        return _units_from_regex(prepared, list(_AR_ART_RE.finditer(prepared)), kind="article", lang="ar")
+        return _ZH_ART_RE
+    if lang == "ar":
+        return _AR_ART_RE
+    if lang == "fa":
+        return _FA_ART_RE
     if lang == "ja":
-        prepared = re.sub(r"(第[0-9一二三四五六七八九十百]+条)", r"\n\1", text)
-        return _units_from_regex(prepared, list(_JA_ART_RE.finditer(prepared)), kind="article", lang="ja")
-    return []
+        return _JA_ART_RE
+    if lang == "ko":
+        return _KO_ART_RE
+    if lang == "he":
+        return _HE_ART_RE
+    if lang == "th":
+        return _TH_ART_RE
+    if lang == "hi":
+        return _HI_ART_RE
+    if lang == "bn":
+        return _BN_ART_RE
+    if lang in {"ru", "uk", "be"}:
+        return _RU_ART_RE
+    if lang == "ka":
+        return _KA_ART_RE
+    if lang == "hy":
+        return _HY_ART_RE
+    if lang == "am":
+        return _AM_ART_RE
+    if lang == "ti":
+        return _TI_ART_RE
+    if lang == "bo":
+        return _BO_ART_RE
+    if lang == "ug":
+        return _UG_ART_RE
+    if lang == "lo":
+        return _LO_ART_RE
+    if lang == "km":
+        return _KM_ART_RE
+    if lang == "my":
+        return _MY_ART_RE
+    if lang == "uz":
+        return _UZ_ART_RE
+    if lang == "mn":
+        return _MN_ART_RE
+    if lang == "kk":
+        return _KK_ART_RE
+    if lang == "ne":
+        return _NE_ART_RE
+    if lang == "si":
+        return _SI_ART_RE
+    if lang == "ta":
+        return _TA_ART_RE
+    if lang == "te":
+        return _TE_ART_RE
+    if lang == "kn":
+        return _KN_ART_RE
+    if lang == "gu":
+        return _GU_ART_RE
+    if lang == "pa":
+        return _PA_ART_RE
+    if lang == "ml":
+        return _ML_ART_RE
+    if lang == "ur":
+        return _UR_ART_RE
+    if lang == "ky":
+        return _KY_ART_RE
+    if lang == "be":
+        return _BE_ART_RE
+    return None
 
 
-def split_structured_units(text: str, *, language: str = "") -> list[StructureUnit]:
-    """Split *text* on legal headings. Empty list means keep the whole instrument.
+def _detected_script_regexes(text: str, language: str) -> list:
+    found: list = []
+    primary = _script_regex(language)
+    if primary is not None:
+        found.append(primary)
+    if re.search(r"[①-⑳⑴-⒇❶-❿⓫-⓴]", text):
+        found.append(_CIRCLED_ART_RE)
+    if re.search(r"[\u4e00-\u9fff]", text):
+        found.extend((_ZH_ART_RE, _JA_ART_RE, _ZH_KUAN_RE, _JA_KOU_RE, _CJK_ZHANG_RE, _CJK_BIAN_RE, _CJK_JIE_RE, _CJK_ENUM_RE, _CJK_PAREN_RE, _CJK_DIGIT_ENUM_RE))
+    if re.search(r"[\uac00-\ud7af]", text):
+        found.extend((_KO_ART_RE, _KO_HANG_RE, _KO_HO_RE, _KO_GA_RE, _KO_JANG_RE, _KO_PYEON_RE, _KO_JEOL_RE))
+    if re.search(r"[\u30a0-\u30ff]", text):
+        found.append(_JA_KATA_ENUM_RE)
+    if re.search(r"[\u0600-\u06ff]", text):
+        found.extend((
+            _AR_ART_RE, _FA_ART_RE, _FA_TAB_RE, _FA_BAND_RE, _FA_FASL_RE, _AR_PARA_RE, _AR_QARAR_RE, _AR_DECREE_RE,
+            _AR_ABJAD_RE, _AR_ANNEX_RE, _AR_BAB_RE, _AR_FASL_RE, _AR_KITAB_RE, _AR_FARA_RE, _UR_CHAP_RE, _UG_ART_RE, _AR_POINT_RE,
+        ))
+    if re.search(r"[\u0590-\u05ff]", text):
+        found.extend((
+            _HE_ART_RE, _HE_PARA_RE, _HE_ALEF_RE, _HE_PEREK_RE, _HE_SIMAN_RE,
+            _HE_HELEK_RE, _HE_TOS_RE, _HE_TAKANA_RE, _HE_KATAN_RE,
+        ))
+    if re.search(r"[\u0e00-\u0e7f]", text):
+        found.extend((_TH_ART_RE, _TH_PARA_RE, _TH_KO_RE, _TH_KHO_RE, _TH_HUAT_RE, _TH_LAK_RE, _TH_TON_RE))
+    if re.search(r"[\u0900-\u097f]", text):
+        found.extend((_HI_ART_RE, _HI_DIGIT_ENUM_RE, _HI_CHAP_RE, _NE_CHAP_RE))
+    if re.search(r"[\u0980-\u09ff]", text):
+        found.extend((_BN_ART_RE, _BN_DIGIT_ENUM_RE, _BN_CHAP_RE))
+    if re.search(r"[\u0b80-\u0bff]", text):
+        found.append(_TA_ART_RE)
+    if re.search(r"[\u0c00-\u0c7f]", text):
+        found.append(_TE_ART_RE)
+    if re.search(r"[\u0c80-\u0cff]", text):
+        found.append(_KN_ART_RE)
+    if re.search(r"[\u0a80-\u0aff]", text):
+        found.append(_GU_ART_RE)
+    if re.search(r"[\u0a00-\u0a7f]", text):
+        found.append(_PA_ART_RE)
+    if re.search(r"[\u0d00-\u0d7f]", text):
+        found.append(_ML_ART_RE)
+    if re.search(r"[\u0e80-\u0eff]", text):
+        found.extend((_LO_ART_RE, _LO_PART_RE))
+    if re.search(r"[\u1780-\u17ff]", text):
+        found.extend((_KM_ART_RE, _KM_CHAP_RE))
+    if re.search(r"[\u1000-\u109f]", text):
+        found.extend((_MY_ART_RE, _MY_CHAP_RE))
+    if re.search(r"[\u1200-\u137f]", text):
+        found.extend((_AM_ART_RE, _AM_CHAP_RE, _TI_ART_RE))
+    if re.search(r"[\u0f00-\u0fff]", text):
+        found.append(_BO_ART_RE)
+    if re.search(r"[\u10a0-\u10ff]", text):
+        found.extend((_KA_ART_RE, _KA_AB_RE, _KA_CHAP_RE))
+    if re.search(r"[\u0530-\u058f]", text):
+        found.extend((_HY_ART_RE, _HY_AB_RE, _HY_CHAP_RE))
+    if re.search(r"[\u0400-\u04ff]", text):
+        found.extend((_CYR_AB_RE, _RU_TITLE_RE, _RU_CHAP_RE, _SR_PART_RE))
+    if re.search(r"[\u0370-\u03ff]", text):
+        found.append(_EL_AB_RE)
+    if "модда" in text.casefold() or re.search(r"\bmodda\b", text, re.IGNORECASE):
+        found.append(_UZ_ART_RE)
+    if re.search(r"зүйл", text, re.IGNORECASE):
+        found.append(_MN_ART_RE)
+    if re.search(r"бап", text, re.IGNORECASE):
+        found.append(_KK_ART_RE)
+    if "दफा" in text:
+        found.append(_NE_ART_RE)
+    if "परिच्छेद" in text:
+        found.append(_NE_CHAP_RE)
+    if "වගන්තිය" in text:
+        found.append(_SI_ART_RE)
+    if "دفعہ" in text:
+        found.append(_UR_ART_RE)
+    if re.search(r"берене", text, re.IGNORECASE):
+        found.append(_KY_ART_RE)
+    if re.search(r"артыкул", text, re.IGNORECASE):
+        found.append(_BE_ART_RE)
+    if re.search(r"статья|стаття", text, re.IGNORECASE):
+        found.append(_RU_ART_RE)
+    if re.search(r"указ|постановление|приказ", text, re.IGNORECASE):
+        found.append(_RU_INST_RE)
+    # Preserve order, drop duplicate pattern objects.
+    out: list = []
+    seen: set[int] = set()
+    for regex in found:
+        key = id(regex)
+        if key not in seen:
+            seen.add(key)
+            out.append(regex)
+    return out
 
-    Latin TITLE/ARTICLE splits are skipped for languages in
-    ``profiles.NO_LATIN_SPLIT_LANGS`` so Arabic/Chinese bodies are not
-    carved up on incidental English words.
-    """
-    from .profiles import latin_split_allowed
 
-    if not text or len(text) < 16:
-        return []
-    if language and not latin_split_allowed(language):
-        return split_script_units(text, language)
-    matches = list(_HEADING_RE.finditer(text))
-    if len(matches) < MIN_SPLIT_HEADINGS:
-        return []
+def _lexicon_heading_re() -> re.Pattern[str]:
+    """Heading matcher generated from HEADING_LEXICON so new languages are data."""
+    global _LEXICON_HEADING_RE, _LEXICON_KIND
+    if _LEXICON_HEADING_RE is not None:
+        return _LEXICON_HEADING_RE
+    from .profiles import HEADING_LEXICON
+
+    words: list[str] = []
+    kinds: dict[str, str] = {}
+    for token, hits in HEADING_LEXICON.items():
+        token = (token or "").strip()
+        if len(token) < 2:
+            continue
+        kinds_found = [kind for kind, _lang in hits if kind in {"article", "section", "title", "chapter", "part"}]
+        if not kinds_found:
+            continue
+        folded = _latin_fold(token)
+        words.append(folded)
+        kinds[folded.casefold()] = kinds_found[0]
+    words.sort(key=len, reverse=True)
+    escaped = [re.escape(w) for w in words]
+    _LEXICON_HEADING_RE = re.compile(
+        _latin_fold(
+        r"(?im)" + _HEADING_START + r"(?:l['’])?(?P<lex>"
+        + "|".join(escaped)
+        + r")(?![A-Za-z])(?:\s*(?:n\.?[o°º”'“*´`]|nr|no)\.?\s*)?\s*[.\s:–—-]*\(?\s*(?P<lex_n>"
+        + _ARTICLE_N
+        + r")\)?"
+        )
+    )
+    _LEXICON_KIND = kinds
+    return _LEXICON_HEADING_RE
+
+
+def _plausible_cw_number(raw: str) -> bool:
+    """Drop year-like '1902. Amendment' titles from keyword-less numbering."""
+    digits = re.sub(r"\D", "", raw or "")
+    if not digits:
+        return False
+    value = int(digits)
+    if value <= 0 or value > 2000:
+        return False
+    if 1800 <= value <= 2099:
+        return False
+    return True
+
+
+def _fold_digits_in_number(raw: str) -> str:
+    """Map Nd digits (١, १, ๑, …) to ASCII so retrieval numbers stay decimal."""
+    if not raw:
+        return raw
+    out: list[str] = []
+    changed = False
+    for ch in raw:
+        if unicodedata.category(ch) == "Nd":
+            digit = unicodedata.digit(ch)
+            if digit is not None:
+                mapped = str(digit)
+                out.append(mapped)
+                if mapped != ch:
+                    changed = True
+                continue
+        out.append(ch)
+    return "".join(out) if changed else raw
+
+
+def _unicode_digit_runs(text: str) -> list[str]:
+    """ASCII-fold Nd runs (Thai ๑, Myanmar ၁, Arabic-Indic, …)."""
+    runs: list[str] = []
+    cur: list[str] = []
+    for char in text:
+        if unicodedata.category(char) == "Nd":
+            cur.append(str(unicodedata.digit(char)))
+        elif cur:
+            runs.append("".join(cur))
+            cur = []
+    if cur:
+        runs.append("".join(cur))
+    return runs
+
+
+_AR_ORDINAL_NUM = (
+    ("الحادية عشرة", "11"),
+    ("الثانية عشرة", "12"),
+    ("الثالثة عشرة", "13"),
+    ("الرابعة عشرة", "14"),
+    ("الخامسة عشرة", "15"),
+    ("السادسة عشرة", "16"),
+    ("��لسابعة عشرة", "17"),
+    ("الثامنة عشرة", "18"),
+    ("التاسعة عشرة", "19"),
+    ("الحادية والعشرون", "21"),
+    ("الثانية والعشرون", "22"),
+    ("الثالثة والعشرون", "23"),
+    ("الرابعة والعشرون", "24"),
+    ("الخامسة والعشرون", "25"),
+    ("السادسة والعشرون", "26"),
+    ("السابعة والعشرون", "27"),
+    ("الثامنة والعشرون", "28"),
+    ("التاسعة والعشرون", "29"),
+    ("العشرون", "20"),
+    ("الأولى", "1"),
+    ("الأولي", "1"),
+    ("األولى", "1"),
+    ("الاولى", "1"),
+    ("الثانية", "2"),
+    ("الثالثة", "3"),
+    ("الرابعة", "4"),
+    ("الخامسة", "5"),
+    ("السادسة", "6"),
+    ("السابعة", "7"),
+    ("الثامنة", "8"),
+    ("التاسعة", "9"),
+    ("العاشرة", "10"),
+    ("الأول", "1"),
+    ("الاول", "1"),
+    ("الثاني", "2"),
+    ("الثالث", "3"),
+    ("الرابع", "4"),
+    ("الخامس", "5"),
+    ("السادس", "6"),
+    ("السابع", "7"),
+    ("الثامن", "8"),
+    ("التاسع", "9"),
+    ("العاشر", "10"),
+)
+_HE_VALUES = {
+    "א": 1, "ב": 2, "ג": 3, "ד": 4, "ה": 5, "ו": 6, "ז": 7, "ח": 8, "ט": 9,
+    "י": 10, "כ": 20, "ך": 20, "ל": 30, "מ": 40, "ם": 40, "נ": 50, "ן": 50,
+    "ס": 60, "ע": 70, "פ": 80, "ף": 80, "צ": 90, "ץ": 90, "ק": 100,
+    "ר": 200, "ש": 300, "ת": 400,
+}
+_HE_ORDINAL_NUM = (
+    ("ראשונה", "1"),
+    ("שנייה", "2"),
+    ("שניה", "2"),
+    ("שלישית", "3"),
+    ("רביעית", "4"),
+    ("חמישית", "5"),
+    ("שישית", "6"),
+)
+_ETH_VALUES = {
+    "፩": 1, "፪": 2, "፫": 3, "፬": 4, "፭": 5, "፮": 6, "፯": 7, "፰": 8, "፱": 9,
+    "፲": 10, "፳": 20, "፴": 30, "፵": 40, "፶": 50, "፷": 60, "፸": 70, "፹": 80, "፺": 90,
+    "፻": 100, "፼": 10000,
+}
+_FA_ORDINAL_NUM = (
+    ("دوازدهم", "12"),
+    ("سیزدهم", "13"),
+    ("چهاردهم", "14"),
+    ("پانزدهم", "15"),
+    ("شانزدهم", "16"),
+    ("هفدهم", "17"),
+    ("هجدهم", "18"),
+    ("نوزدهم", "19"),
+    ("یازدهم", "11"),
+    ("بیستم", "20"),
+    ("چهارم", "4"),
+    ("چارم", "4"),
+    ("جارم", "4"),
+    ("پنجم", "5"),
+    ("ششم", "6"),
+    ("هفتم", "7"),
+    ("هشتم", "8"),
+    ("نهم", "9"),
+    ("دهم", "10"),
+    ("سوم", "3"),
+    ("دوم", "2"),
+    ("اولی", "1"),
+    ("اول", "1"),
+    ("نخست", "1"),
+)
+_CJK_DIGIT = {
+    "零": 0, "〇": 0, "一": 1, "二": 2, "三": 3, "四": 4,
+    "五": 5, "六": 6, "七": 7, "八": 8, "九": 9,
+}
+
+
+def _cjk_numeral_value(text: str) -> str | None:
+    body = re.sub(r"[第条條項款章编編节節之조항호편절、]", "", text)
+    if not body or not all(ch in _CJK_DIGIT or ch == "十" or ch == "百" for ch in body):
+        return None
+    if body == "十":
+        return "10"
+    if body.startswith("十"):
+        return str(10 + _CJK_DIGIT.get(body[1], 0))
+    if "百" in body:
+        left, right = body.split("百", 1)
+        if not left:
+            hundreds = 100
+        elif left in _CJK_DIGIT:
+            hundreds = _CJK_DIGIT[left] * 100
+        else:
+            return None
+        if not right:
+            return str(hundreds)
+        rest = _cjk_numeral_value(right)
+        if rest is None:
+            return None
+        return str(hundreds + int(rest))
+    if "十" in body:
+        left, right = body.split("十", 1)
+        tens = _CJK_DIGIT.get(left, 0) * 10
+        ones = _CJK_DIGIT.get(right, 0) if right else 0
+        return str(tens + ones)
+    if body in _CJK_DIGIT:
+        return str(_CJK_DIGIT[body])
+    return None
+
+
+def _circled_to_int(char: str) -> str | None:
+    if not char:
+        return None
+    code = ord(char[0])
+    if 0x2460 <= code <= 0x2473:
+        return str(code - 0x2460 + 1)
+    if 0x2474 <= code <= 0x2487:
+        return str(code - 0x2474 + 1)
+    if 0x2488 <= code <= 0x249B:
+        return str(code - 0x2488 + 1)
+    if 0x2776 <= code <= 0x277F:
+        return str(code - 0x2776 + 1)
+    if 0x24EB <= code <= 0x24F4:
+        return str(code - 0x24EB + 11)
+    return None
+
+
+def _ethiopic_numeral_value(text: str) -> str | None:
+    chars = [ch for ch in text if ch in _ETH_VALUES]
+    if not chars:
+        return None
+    body = "".join(chars)
+    if "፼" in body:
+        left, right = body.split("፼", 1)
+        mul = _ethiopic_numeral_value(left) if left else "1"
+        rest = _ethiopic_numeral_value(right) if right else "0"
+        if mul is None or rest is None:
+            return None
+        return str(int(mul) * 10000 + int(rest))
+    if "፻" in body:
+        left, right = body.split("፻", 1)
+        mul = sum(_ETH_VALUES[ch] for ch in left) if left else 1
+        rest = sum(_ETH_VALUES[ch] for ch in right)
+        return str(mul * 100 + rest)
+    return str(sum(_ETH_VALUES[ch] for ch in chars))
+
+
+def _hebrew_letter_num(raw: str) -> str | None:
+    """Map פרק א' / תוספת שניה / סעיף יא to decimal. Long Hebrew words stay unmapped."""
+    cleaned = re.sub(r"['׳״\"`]", "", raw)
+    for word, num in _HE_ORDINAL_NUM:
+        if word in cleaned:
+            return num
+    katan = re.search(r"סעיף\s+קטן\s*\(?\s*([א-ת])", cleaned)
+    if katan:
+        ch = katan.group(1)
+        return str(_HE_VALUES[ch]) if ch in _HE_VALUES else ch
+    match = re.search(r"(?:פרק|סימן|חלק|תוספת|סעיף)\s*(?!קטן)([א-ת]{1,3})", cleaned)
+    if not match:
+        return None
+    total = sum(_HE_VALUES.get(ch, 0) for ch in match.group(1))
+    return str(total) if total else None
+
+
+def _script_hit_kind(regex: re.Pattern[str]) -> str:
+    if regex is _RU_TITLE_RE or regex is _TH_LAK_RE:
+        return "title"
+    if regex in (
+        _HE_PEREK_RE, _AR_BAB_RE, _TH_HUAT_RE, _CJK_ZHANG_RE, _KO_JANG_RE,
+        _RU_CHAP_RE, _KM_CHAP_RE, _MY_CHAP_RE, _KA_CHAP_RE, _HY_CHAP_RE, _AM_CHAP_RE,
+        _HI_CHAP_RE, _BN_CHAP_RE, _UR_CHAP_RE, _FA_FASL_RE, _NE_CHAP_RE,
+    ):
+        return "chapter"
+    if regex in (_HE_HELEK_RE, _AR_KITAB_RE, _CJK_BIAN_RE, _KO_PYEON_RE, _LO_PART_RE, _SR_PART_RE):
+        return "part"
+    if regex in (
+        _HE_SIMAN_RE,
+        _HE_TOS_RE,
+        _HE_TAKANA_RE,
+        _HE_PARA_RE,
+        _HE_KATAN_RE,
+        _AR_ANNEX_RE,
+        _AR_PARA_RE,
+        _AR_FASL_RE,
+        _AR_FARA_RE,
+        _JA_KOU_RE,
+        _ZH_KUAN_RE,
+        _KO_HANG_RE,
+        _KO_HO_RE,
+        _TH_PARA_RE,
+        _TH_KHO_RE,
+        _TH_TON_RE,
+        _FA_TAB_RE,
+        _FA_BAND_RE,
+        _AR_POINT_RE,
+        _CJK_JIE_RE,
+        _KO_JEOL_RE,
+    ):
+        return "section"
+    return "article"
+
+
+def _script_article_number(raw: str) -> str:
+    stripped = raw.strip()
+    for word, num in _AR_POINT_NUM:
+        if stripped.startswith(word):
+            return num
+    compact = raw.strip().strip("()[] \t\u3001\uff08\uff09.、-–—")
+    circled = _circled_to_int(compact)
+    if circled:
+        return circled
+    if compact and len(compact) <= 3:
+        first = compact[0]
+        if first in _HANGUL_GA:
+            return str(_HANGUL_GA.index(first) + 1)
+        if first in _KATA_ENUM:
+            return str(_KATA_ENUM.index(first) + 1)
+        if first in _AR_ABJAD_INDEX:
+            return _AR_ABJAD_INDEX[first]
+        if first in _HE_ALEF:
+            return str(_HE_ALEF.index(first) + 1)
+        if first in _TH_KO:
+            return str(_TH_KO.index(first) + 1)
+        low = first.casefold()
+        if low in _CYR_AB:
+            return str(_CYR_AB.index(low) + 1)
+        if low in _EL_AB:
+            return str(_EL_AB.index(low) + 1)
+        if first in _KA_AB:
+            return str(_KA_AB.index(first) + 1)
+        if first in _HY_AB:
+            return str(_HY_AB.index(first) + 1)
+        cjk_early = _cjk_numeral_value(compact)
+        if cjk_early:
+            return cjk_early
+    he = _hebrew_letter_num(raw)
+    if he:
+        return he
+    digits = _unicode_digit_runs(raw)
+    if digits:
+        if len(digits) >= 2 and re.search(r"[0-9٠-٩۰-۹]+-[0-9٠-٩۰-۹]+", raw):
+            return "-".join(digits[:2])
+        return digits[0]
+    eth = _ethiopic_numeral_value(raw)
+    if eth:
+        return eth
+    compact = re.sub(r"[\s\u0640]+", "", raw)
+    for word, num in _AR_ORDINAL_NUM + _FA_ORDINAL_NUM:
+        needle = re.sub(r"[\s\u0640]+", "", word)
+        if needle and needle in compact:
+            return num
+    cjk = _cjk_numeral_value(compact)
+    if cjk:
+        return cjk
+    tail = re.search(r"([0-9٠-٩۰-۹]+|[IVXLCDM]{1,8})$", compact)
+    if tail:
+        return tail.group(1)
+    return compact
+
+
+def _in_range_boilerplate(text: str, start: int) -> bool:
+    for regex in (_KO_RANGE_RE, _CJK_RANGE_RE):
+        for match in regex.finditer(text):
+            if match.start() <= start < match.end():
+                return True
+    return False
+
+
+def _kind_number_from_heading_match(match: re.Match) -> tuple[str, str]:
+    for name in ("title", "chapter", "part", "article", "section"):
+        if match.group(name):
+            return name, (match.group(f"{name}_n") or "").strip()
+    if match.group("section_sym"):
+        return "section", (match.group("section_sym_n") or "").strip()
+    if match.group("section_pre"):
+        return "section", (match.group("section_pre_n") or "").strip()
+    if match.group("grein"):
+        return "article", (match.group("grein_n") or "").strip()
+    if match.group("straipsnis"):
+        return "article", (match.group("straipsnis_n") or "").strip()
+    if match.group("artikulua"):
+        return "article", (match.group("artikulua_n") or "").strip()
+    if match.group("ledd"):
+        return "section", (match.group("ledd_n") or "").strip()
+    if match.group("kap"):
+        return "chapter", (match.group("kap_n") or "").strip()
+    if match.group("luku"):
+        return "chapter", (match.group("luku_n") or "").strip()
+    if match.group("fejezet"):
+        return "chapter", (match.group("fejezet_n") or "").strip()
+    if match.group("peatukk"):
+        return "chapter", (match.group("peatukk_n") or "").strip()
+    if match.group("skyrius"):
+        return "chapter", (match.group("skyrius_n") or "").strip()
+    if match.group("nodala"):
+        return "chapter", (match.group("nodala_n") or "").strip()
+    if match.group("kafli"):
+        return "chapter", (match.group("kafli_n") or "").strip()
+    if match.group("bob"):
+        return "chapter", (match.group("bob_n") or "").strip()
+    if match.group("tarau"):
+        return "chapter", (match.group("tarau_n") or "").strip()
+    if match.group("bolum"):
+        return "chapter", (match.group("bolum_n") or "").strip()
+    if match.group("modda"):
+        return "article", (match.group("modda_n") or "").strip()
+    if match.group("mn"):
+        return "article", (match.group("mn_n") or "").strip()
+    if match.group("kk"):
+        return "article", (match.group("kk_n") or "").strip()
+    if match.group("disp"):
+        return "article", (match.group("disp_n") or "").strip()
+    if match.group("mom"):
+        return "section", (match.group("mom_n") or "").strip()
+    if match.group("order"):
+        return "section", (match.group("order_n") or "").strip()
+    if match.group("kidogo"):
+        return "section", (match.group("kidogo_n") or "").strip()
+    if match.group("esresol"):
+        word = _latin_fold(match.group("esresol") or "").casefold()
+        return "section", {
+            "primero": "1", "segundo": "2", "tercero": "3", "cuarto": "4",
+            "quinto": "5", "sexto": "6", "septimo": "7", "octavo": "8",
+            "noveno": "9", "decimo": "10",
+            "erstens": "1", "zweitens": "2", "drittens": "3", "viertens": "4", "funftens": "5",
+            "premierement": "1", "deuxiemement": "2", "troisiemement": "3",
+            "quatriemement": "4", "cinquiemement": "5",
+        }.get(word, word)
+    return "", ""
+
+
+@dataclass
+class _Hit:
+    start: int
+    kind: str
+    number: str
+    heading: str
+
+
+_PAREN_XREF_RE = re.compile(
+    r"(?i)^\s*(?:\([a-z0-9]{1,4}\))?\s+"
+    r"(?:is|are|or|and|of|have|has|was|were|by|to|for|from|in|that|shall)\b"
+)
+
+
+def _paren_letter_xref(raw: str, number: str, rest: str) -> bool:
+    """Skip 'paragraph (i) or …' / 'subsection (l)(b) is …' cross-references."""
+    if len(number) != 1 or not number.isalpha() or "(" not in raw:
+        return False
+    return _PAREN_XREF_RE.match(rest) is not None
+
+
+def _collect_hits(text: str, *, language: str, latin: bool) -> list[_Hit]:
+    hits: list[_Hit] = []
+    folded = _latin_fold(text) if latin else text
+    if latin:
+        for match in _HEADING_RE.finditer(folded):
+            kind, number = _kind_number_from_heading_match(match)
+            if not kind:
+                continue
+            if _CITE_TAIL_RE.match(folded[match.end() : match.end() + 48]):
+                continue
+            if _paren_letter_xref(match.group(0), number, folded[match.end() : match.end() + 48]):
+                continue
+            for gname in (
+                "title_n", "chapter_n", "part_n", "article_n", "section_n",
+                "section_sym_n", "section_pre_n", "grein_n", "straipsnis_n",
+                "artikulua_n", "ledd_n", "kap_n", "luku_n",
+                "fejezet_n", "peatukk_n", "skyrius_n", "nodala_n",
+                "kafli_n", "bob_n", "tarau_n", "bolum_n",
+                "modda_n", "mn_n", "kk_n", "mom_n", "order_n", "kidogo_n", "disp_n",
+            ):
+                try:
+                    start, end = match.span(gname)
+                except IndexError:
+                    continue
+                if start >= 0:
+                    number = text[start:end]
+                    break
+            number = _fold_digits_in_number(number.strip().rstrip(".-:–—"))
+            line_end = text.find("\n", match.start())
+            if line_end < 0:
+                line_end = len(text)
+            heading = re.sub(r"\s+", " ", text[match.start() : line_end]).strip()[:240]
+            hits.append(_Hit(match.start(), kind, number, heading))
+        for match in _lexicon_heading_re().finditer(folded):
+            if _CITE_TAIL_RE.match(folded[match.end() : match.end() + 48]):
+                continue
+            token = (match.group("lex") or "").casefold()
+            kind = _LEXICON_KIND.get(token, "article")
+            start, end = match.span("lex_n")
+            number = _fold_digits_in_number(
+                (text[start:end] if start >= 0 else match.group("lex_n") or "").strip().rstrip(".-:–—")
+            )
+            if not number:
+                continue
+            line_end = text.find("\n", match.start())
+            if line_end < 0:
+                line_end = len(text)
+            heading = re.sub(r"\s+", " ", text[match.start() : line_end]).strip()[:240]
+            hits.append(_Hit(match.start(), kind, number, heading))
+    for match in _LATIN_LETTER_RE.finditer(text):
+        letter = match.group("paren") or match.group("bare")
+        if letter:
+            number = str(ord(letter) - 96)
+        else:
+            number = _ROMAN_LOWER.get(match.group("roman") or "", "")
+        if not number:
+            continue
+        line_end = text.find("\n", match.start())
+        if line_end < 0:
+            line_end = len(text)
+        heading = re.sub(r"\s+", " ", text[match.start() : line_end]).strip()[:240]
+        hits.append(_Hit(match.start(), "section", number, heading))
+    for match in _LATIN_NUM_LIST_RE.finditer(text):
+        number = (
+            match.group("nparen")
+            or match.group("nclose")
+            or match.group("nord")
+            or match.group("ndot")
+            or match.group("ncolon")
+            or match.group("ndash")
+            or ""
+        )
+        dbl = match.group("dbl")
+        if dbl:
+            number = str(ord(dbl[0]) - 96)
+        if not number:
+            continue
+        line_end = text.find("\n", match.start())
+        if line_end < 0:
+            line_end = len(text)
+        heading = re.sub(r"\s+", " ", text[match.start() : line_end]).strip()[:240]
+        hits.append(_Hit(match.start(), "section", number, heading))
+    for i, match in enumerate(_BULLET_RE.finditer(text), start=1):
+        line_end = text.find("\n", match.start())
+        if line_end < 0:
+            line_end = len(text)
+        heading = re.sub(r"\s+", " ", text[match.start() : line_end]).strip()[:240]
+        hits.append(_Hit(match.start(), "section", str(i), heading))
+    for match in _DASH_NUM_RE.finditer(text):
+        number = (match.group("bn") or "").strip()
+        if not number:
+            continue
+        line_end = text.find("\n", match.start())
+        if line_end < 0:
+            line_end = len(text)
+        heading = re.sub(r"\s+", " ", text[match.start() : line_end]).strip()[:240]
+        hits.append(_Hit(match.start(), "section", number, heading))
+    for regex in _detected_script_regexes(text, language):
+        for match in regex.finditer(text):
+            if _in_range_boilerplate(text, match.start()):
+                continue
+            if _SCRIPT_CITE_TAIL_RE.match(text[match.end() : match.end() + 48]):
+                continue
+            raw = match.group(0)
+            number = _fold_digits_in_number(_script_article_number(raw))
+            heading = re.sub(r"\s+", " ", raw).strip()[:240]
+            hits.append(_Hit(match.start(), _script_hit_kind(regex), number, heading))
+    if latin:
+        from .profiles import iso_lang
+
+        lang = iso_lang(language)
+        keyword_hits = [h for h in hits if h.kind in {"article", "section"}]
+        if len(keyword_hits) < MIN_SPLIT_HEADINGS and lang in _CW_NUM_LANGS:
+            for match in _CW_NUM_RE.finditer(text):
+                number = (match.group("cw_n") or "").strip()
+                if not _plausible_cw_number(number):
+                    continue
+                if _MONTH_START_RE.match(text[match.end() : match.end() + 16]):
+                    continue
+                hits.append(
+                    _Hit(
+                        match.start(),
+                        "section",
+                        number,
+                        match.group(0).strip()[:240],
+                    )
+                )
+    hits.sort(key=lambda h: (h.start, -len(h.heading)))
+    merged: list[_Hit] = []
+    seen_starts: set[int] = set()
+    for hit in hits:
+        if hit.start in seen_starts:
+            continue
+        seen_starts.add(hit.start)
+        merged.append(hit)
+    return merged
+
+
+def _units_from_hits(text: str, hits: list[_Hit]) -> list[StructureUnit]:
+    if not hits:
+        return [
+            StructureUnit(kind="preamble", number="", heading="", body=text, char_start=0, char_end=len(text))
+        ]
     cursor = {"title": "", "chapter": "", "part": "", "article": "", "section": ""}
     units: list[StructureUnit] = []
-    for i, match in enumerate(matches):
-        start = match.start()
-        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
-        chunk = text[start:end].strip()
-        kind = ""
-        number = ""
-        for name in ("title", "chapter", "part", "article", "section"):
-            if match.group(name):
-                kind = name
-                number = (match.group(f"{name}_n") or "").strip()
-                break
-        if match.group("section_sym"):
-            kind = "section"
-            number = (match.group("section_sym_n") or "").strip()
-        if not kind or not number:
-            continue
-        cursor[kind] = number
+    if hits[0].start > 0:
+        units.append(
+            StructureUnit(
+                kind="preamble",
+                number="",
+                heading="",
+                body=text[0 : hits[0].start],
+                char_start=0,
+                char_end=hits[0].start,
+            )
+        )
+    for i, hit in enumerate(hits):
+        start = hit.start
+        end = hits[i + 1].start if i + 1 < len(hits) else len(text)
+        body = text[start:end]
+        cursor[hit.kind] = hit.number
         for lower, rank in _KIND_RANK.items():
-            if rank > _KIND_RANK[kind]:
+            if rank > _KIND_RANK.get(hit.kind, 99):
                 cursor[lower] = ""
-        if len(chunk) < MIN_UNIT_CHARS:
-            continue
-        rest = (match.group("rest") or "").strip(" .-:")
-        heading = re.sub(r"\s+", " ", match.group(0)).strip()
-        if rest and rest not in heading:
-            heading = f"{heading} {rest}".strip()
         units.append(
             StructureUnit(
-                kind=kind,
-                number=number,
-                heading=heading[:240],
-                body=chunk,
+                kind=hit.kind,
+                number=hit.number,
+                heading=hit.heading[:240],
+                body=body,
                 title_number=cursor["title"],
                 chapter_number=cursor["chapter"],
                 part_number=cursor["part"],
                 article_number=cursor["article"],
                 section_number=cursor["section"],
-                subsections=_subsection_tokens(chunk),
+                subsections=_subsection_tokens(body),
                 hierarchy_path=_cursor_path(cursor),
+                char_start=start,
+                char_end=end,
             )
         )
-    retrieval = [u for u in units if u.kind in {"article", "section"}]
-    if len(retrieval) >= MIN_SPLIT_HEADINGS:
-        return retrieval
-    if len(units) >= MIN_SPLIT_HEADINGS:
-        return units
+    return units
+
+
+def segment_exclusive(text: str, *, language: str = "") -> list[StructureUnit]:
+    """Internal exclusive-span segmentation of *text* (includes preamble)."""
+    from .profiles import iso_lang, latin_split_allowed
+
+    if not text:
+        return []
+    latin = not language or latin_split_allowed(language)
+    hits = _collect_hits(text, language=language, latin=latin)
+    retrieval_like = [h for h in hits if h.kind in {"article", "section"}]
+    if (
+        not latin
+        and len(retrieval_like) < MIN_SPLIT_HEADINGS
+        and iso_lang(language) in _LATIN_FALLBACK_LANGS
+    ):
+        hits = _collect_hits(text, language=language, latin=True)
+    return _units_from_hits(text, hits)
+
+
+def split_script_units(text: str, language: str) -> list[StructureUnit]:
+    """Retrieval projection of script-specific exclusive spans."""
+    internal = segment_exclusive(text, language=language)
+    retrieval = [u for u in internal if u.kind == "article" and len(u.body.strip()) >= 16]
+    return retrieval if len(retrieval) >= MIN_SPLIT_HEADINGS else []
+
+
+def split_structured_units(text: str, *, language: str = "") -> list[StructureUnit]:
+    """Retrieval units. Empty list means keep the whole instrument.
+
+    Prefers article/section. When those are scarce, numbered chapter then title
+    headings (Cameroon CHAPITRE, Bolivia TÍTULO, Cape Verde CAPÍTULO).
+    """
+    if not text or len(text) < 16:
+        return []
+    from .profiles import latin_split_allowed
+
+    internal = segment_exclusive(text, language=language)
+
+    def _take(kinds: set[str]) -> list[StructureUnit]:
+        out: list[StructureUnit] = []
+        for u in internal:
+            if u.kind not in kinds:
+                continue
+            min_len = 16 if u.number else MIN_UNIT_CHARS
+            if language and not latin_split_allowed(language):
+                min_len = 16
+            if len(u.body.strip()) >= min_len:
+                out.append(u)
+        return out
+
+    for kinds in (
+        {"article", "section"},
+        {"chapter"},
+        {"part"},
+        {"title"},
+    ):
+        retrieval = _take(kinds)
+        if len(retrieval) >= MIN_SPLIT_HEADINGS:
+            return retrieval
     return []

country_laws_ir/upload.py

@@ -20,10 +20,82 @@ _OPERATOR_HINT = (
 )
 
 
+CARD_FILES = (
+    "README.md",
+    ".gitattributes",
+    "manifest.json",
+    "dataset_configs.json",
+    "normalization_report.json",
+)
+
+
 class UploadError(RuntimeError):
     """Raised when a JusticeDAO upload cannot proceed."""
 
 
+def ensure_dataset_card(local_dir: Path) -> Path:
+    """Write a YAML dataset card if README.md is missing or is a Hub stub."""
+    from .package import _write_readme
+
+    local_dir = Path(local_dir)
+    readme = local_dir / "README.md"
+    text = readme.read_text(encoding="utf-8") if readme.is_file() else ""
+    if text.startswith("---") and "pretty_name:" in text:
+        return readme
+    manifest_path = local_dir / "manifest.json"
+    if not manifest_path.is_file():
+        raise UploadError(f"cannot build dataset card; missing {manifest_path}")
+    import json
+
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    country = manifest.get("country") or {}
+    source_meta = manifest.get("source") or {
+        "source_dataset": manifest.get("dataset_id") or "",
+        "source_revision": manifest.get("dataset_revision") or "",
+    }
+    hub_id = str(manifest.get("dataset_repo_id") or f"{TARGET_ORG}/ipfs_{country.get('slug', 'unknown')}_laws_ir")
+    _write_readme(
+        local_dir,
+        country,
+        source_meta,
+        manifest.get("counts") or {},
+        manifest.get("bm25") or {},
+        manifest.get("graph") or {},
+        manifest.get("vector") or {},
+        hub_id,
+        normalization_report=manifest.get("normalization"),
+    )
+    return readme
+
+
+def _commit_dataset_card(api: Any, local_dir: Path, repo_id: str) -> str:
+    """Always commit README/metadata after parquet upload.
+
+    ``upload_large_folder`` often finishes LFS parquet commits while leaving
+    a Hub-generated stub README (no YAML card). Regular files are committed
+    here in a follow-up so the dataset page always has a parseable card.
+    """
+    from huggingface_hub import CommitOperationAdd
+
+    ensure_dataset_card(local_dir)
+    operations = []
+    for name in CARD_FILES:
+        path = local_dir / name
+        if path.is_file():
+            operations.append(
+                CommitOperationAdd(path_in_repo=name, path_or_fileobj=str(path))
+            )
+    if not operations:
+        return ""
+    info = api.create_commit(
+        repo_id=repo_id,
+        repo_type="dataset",
+        operations=operations,
+        commit_message="Add YAML dataset card and release metadata",
+    )
+    return str(getattr(info, "oid", None) or getattr(info, "commit_id", None) or "")
+
+
 def _token_from_env() -> str:
     for key in ("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN"):
         value = (os.environ.get(key) or "").strip()
@@ -92,6 +164,7 @@ def upload_release(
     n_files = sum(1 for path in local_dir.rglob("*") if path.is_file())
     nbytes = sum(path.stat().st_size for path in local_dir.rglob("*") if path.is_file())
     use_large = n_files >= 80 or nbytes >= 80 * 1024 * 1024
+    method = "upload_folder"
     if use_large and hasattr(api, "upload_large_folder"):
         api.upload_large_folder(
             folder_path=str(local_dir),
@@ -99,7 +172,19 @@ def upload_release(
             repo_type="dataset",
             ignore_patterns=ignore,
         )
-        revision = ""
+        method = "upload_large_folder"
+    else:
+        api.upload_folder(
+            folder_path=str(local_dir),
+            repo_id=repo_id,
+            repo_type="dataset",
+            commit_message=commit_message
+            or f"Incremental country-laws-ir GraphRAG release for {repo_id}",
+            ignore_patterns=ignore,
+        )
+    card_sha = _commit_dataset_card(api, local_dir, repo_id)
+    revision = card_sha
+    if not revision:
         try:
             from huggingface_hub import dataset_info as _dataset_info
 
@@ -107,26 +192,10 @@ def upload_release(
             revision = str(getattr(pinned, "sha", "") or "")
         except Exception:
             revision = ""
-        return {
-            "url": f"https://huggingface.co/datasets/{repo_id}",
-            "repo_id": repo_id,
-            "revision": revision,
-            "local_dir": str(local_dir),
-            "method": "upload_large_folder",
-        }
-    info = api.upload_folder(
-        folder_path=str(local_dir),
-        repo_id=repo_id,
-        repo_type="dataset",
-        commit_message=commit_message
-        or f"Incremental country-laws-ir GraphRAG release for {repo_id}",
-        ignore_patterns=ignore,
-    )
-    revision = getattr(info, "oid", None) or getattr(info, "commit_id", None) or ""
     return {
         "url": f"https://huggingface.co/datasets/{repo_id}",
         "repo_id": repo_id,
         "revision": revision,
         "local_dir": str(local_dir),
-        "method": "upload_folder",
+        "method": method,
     }

country_laws_ir/verify.py

@@ -189,6 +189,112 @@ def check_heading_language(corpus: pd.DataFrame, report: dict[str, Any]) -> Chec
     )
 
 
+def check_reconstruction_grounded(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    """Parent reconstructed body must equal glue of child title/number/body."""
+    from .reconstruct import expected_glue_from_children
+
+    if corpus is None or corpus.empty:
+        return Check(
+            id="reconstruction_grounded",
+            severity="fail",
+            passed=True,
+            message="no corpus",
+            evidence={},
+        )
+    if "reconstructed_from_articles" not in corpus.columns:
+        return Check(
+            id="reconstruction_grounded",
+            severity="warn",
+            passed=True,
+            message="no reconstruction columns",
+            evidence={},
+        )
+    mismatches = 0
+    checked = 0
+    samples: list[str] = []
+    laws = corpus[corpus["record_type"] == "law"] if "record_type" in corpus.columns else corpus
+    for rec in laws.itertuples(index=False):
+        if not bool(getattr(rec, "reconstructed_from_articles", False)):
+            continue
+        if str(getattr(rec, "reconstruction_gap_note", "") or "") in {
+            "rss_abort_slug",
+            "reconstruct_budget",
+        }:
+            continue
+        checked += 1
+        iid = str(getattr(rec, "instrument_id", "") or "")
+        kids = corpus[
+            (corpus["instrument_id"] == iid) & (corpus["record_type"].isin(["article", "section"]))
+        ]
+        children = [
+            {
+                "id": str(getattr(k, "source_id", "") or ""),
+                "title": str(getattr(k, "article_title", "") or getattr(k, "title", "") or ""),
+                "article_number": str(getattr(k, "article_number", "") or ""),
+                "body": str(getattr(k, "body", "") or ""),
+            }
+            for k in kids.itertuples(index=False)
+        ]
+        expected = expected_glue_from_children(children)
+        body = str(getattr(rec, "body", "") or "")
+        if bool(getattr(rec, "reconstruction_truncated", False)):
+            if not expected.startswith(body) and body != expected[: len(body)]:
+                mismatches += 1
+                if len(samples) < 5:
+                    samples.append(iid)
+            continue
+        if body != expected:
+            mismatches += 1
+            if len(samples) < 5:
+                samples.append(iid)
+    ok = mismatches == 0
+    return Check(
+        id="reconstruction_grounded",
+        severity="fail",
+        passed=ok,
+        message="reconstructed parents match child glue" if ok else f"{mismatches} reconstructed parents fail glue",
+        evidence={"checked": checked, "mismatches": mismatches, "samples": samples},
+    )
+
+
+def check_empty_parents_reconstructed(report: dict[str, Any]) -> Check:
+    n = int(report.get("n_empty_parents_with_articles_not_reconstructed") or 0)
+    return Check(
+        id="empty_parents_with_articles",
+        severity="fail",
+        passed=n == 0,
+        message="eligible empty parents all have law rows" if n == 0 else f"{n} empty parents with articles were dropped",
+        evidence={"n_empty_parents_with_articles_not_reconstructed": n},
+    )
+
+
+def check_parent_laws(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
+    """Fail if source had instruments but GraphRAG corpus has no law rows."""
+    n_in = int(report.get("n_laws_in") or 0)
+    n_law_rows = 0
+    if corpus is not None and not corpus.empty and "record_type" in corpus.columns:
+        n_law_rows = int((corpus["record_type"] == "law").sum())
+    n_law_rows = int(report.get("n_law_rows") or n_law_rows)
+    if n_in > 0 and n_law_rows == 0:
+        return Check(
+            id="parent_laws",
+            severity="fail",
+            passed=False,
+            message=(
+                f"source has {n_in} laws but corpus has 0 law rows "
+                "(articles were indexed without parent instruments)"
+            ),
+            evidence={"n_laws_in": n_in, "n_law_rows": n_law_rows},
+        )
+    return Check(
+        id="parent_laws",
+        severity="warn",
+        passed=True,
+        message=f"parent instruments present ({n_law_rows} law rows from {n_in} source laws)",
+        evidence={"n_laws_in": n_in, "n_law_rows": n_law_rows},
+    )
+
+
 def check_structure(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
     unit = str(report.get("unit") or "")
     n = int(len(corpus)) if corpus is not None else 0
@@ -204,7 +310,7 @@ def check_structure(corpus: pd.DataFrame, report: dict[str, Any]) -> Check:
     coverage = structured_rows / float(n) if n else 0.0
     # Article or structured units are success. Pure law-level is a warning, not a fail:
     # many gazettes have no title/section markers.
-    if unit in {"article", "structured"} or coverage >= 0.5:
+    if unit in {"article", "structured", "law+article", "law+structured"} or coverage >= 0.5:
         return Check(
             id="legal_structure",
             severity="warn",
@@ -237,6 +343,9 @@ def verify_normalized_corpus(
         check_no_invented_text(report),
         check_html_residual(corpus),
         check_short_bodies(corpus),
+        check_parent_laws(corpus, report),
+        check_reconstruction_grounded(corpus, report),
+        check_empty_parents_reconstructed(report),
         check_structure(corpus, report),
         check_heading_language(corpus, report),
     ]

data/bm25/documents/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5474555d602d4a7edcf8bdf1f407a7e1905a3a2b704c44b7b08af1006be365d1
-size 78266
+oid sha256:9f4a910d1fba32214113195e82134acb6a71f225fa3dd3fcdc71e7dcc0a4cc69
+size 87904

data/bm25/postings/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9410736739d0cd1746c869c64642a5a98cb22ef3962c7e172239b5960161c7ec
-size 20303
+oid sha256:7ba3a86ca7ba2e1f79f148067d70c9fce30ba5ce2acd443a27748419f6413a16
+size 58922

data/bm25/postings/part-000001.parquet

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

data/bm25/postings/part-000002.parquet

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

data/bm25/postings/part-000003.parquet

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

data/corpus/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e70ac30b4b56d6e25e0973d32a92788e6c4a547f1bc6921b1dc10e03bb110a8e
-size 229523
+oid sha256:4a92e53e79d3ebdea257eb8a638a1039e3b5984fc79c0bcda3c9ea3e694a45b1
+size 1092458

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

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ca2e1cbf64c7d4848f1d4fdd2a224d2c51d34b7c51bf8f4b15d35688d481a093
-size 211721
+oid sha256:7c5d2c781d657e8b6d964e4ca11af9754875c9581a6408d80c59a907634d5c3e
+size 237661

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

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:67c810d6aba1b5fd44208b87a13b672ba7f055a969443bba0d952f05d19099bd
-size 207027
+oid sha256:a8c904567de8342b197b0a234fe4eebf786aaa40f3e1b3086d57f5f1ea83cd1a
+size 233161

data/graph/edges/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0f4511a9923aef70c894f68ebaf322afee7fa1f905a5bc40b679ebe37c516e5e
-size 183618
+oid sha256:a5363848a84b37ebcc35477878b52f45e66474e94e094aa5f5723aea1bf4a82e
+size 189600

data/graph/edges/part-000001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1ca5c45475d143dce45c0d3056dfb43c2eba3187a03ff9fbfbbb30ab94b30aa6
-size 49259
+oid sha256:ee149999a2b980e87ed4aed5e2c690530a344215dd730676c20a115e2d21105e
+size 75033

data/graph/nodes/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a4f48b420b047e94a1699bb085672cd27482c51b0dc09e69f451d3bea13c7b47
-size 58340
+oid sha256:c60b4b506b4bfffe5d2fd108aa1dd175db8702ce6b0b16c0029e4f0a250b9293
+size 68213

data/vectors/part-000000.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ee26f8d7e877052567f07adb65fcf8bd3fd4c0de82946e04dba4cb4ae52ee589
-size 1425513
+oid sha256:9918c8841cf13820d4ff95b3fcabaca96194766f4fa96378ae8a70359b78d673
+size 1545290

indexes/bm25_document_chunks.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8e1679b05c5b5d4270bf0bed0fa2e55b78e5b088ca711887e9294d09dd08527f
-size 4578
+oid sha256:121aa3a0d165362b2c24fe963a3fd84c574f4da5f4cfef04967937f4c85f5dea
+size 4577

indexes/bm25_keyword_shards.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1db292df1497260f33c87750cdb8ebfe16b5c71edc0bb2941b44a2cef03d83ee
-size 4821
+oid sha256:e8921c612feeaa7fdb9d780325488fa7d34f072c86562cc2b07d379f5fd55c30
+size 5215

indexes/corpus_chunks.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:93e99fba5dc0325bc2c7827ad087fd6c7540ae40649f18e27782072d601f14e8
+oid sha256:d20f1d1b8c4907428e637ccf5d3c702e405c52c0ca690d26ff056d8e4a7ee9ea
 size 8604

indexes/graph_edge_chunks.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:42ccd9d379a5e4b71cd774eb98f166e3e6fdfca1bba2ee17aa238c91f0373595
-size 5008
+oid sha256:74b38c065c8d3fcce1f08cfecf466db16008d8f461b5cb10d9977f7ede38f79a
+size 5001

indexes/graph_in_adjacency.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:698ddf18757c896d7b56de772e7bf5ad3ae6c88139c28cd581b933ba616597f0
-size 6348
+oid sha256:48ebb41cc4fdaeb77df91c6235b604bd6dd1c5208eede19076ca7ea088b883aa
+size 6349

indexes/graph_node_chunks.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:88d533b3e29d6374cefb359fe7e397ff839c3e26fdfdc87a90de11b77aa47ab6
+oid sha256:2f576473dd8fd9213d3fc25f3df3fc585e54d2fee357bf93d5f720b9ff00d814
 size 4768

indexes/graph_out_adjacency.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:90f496bdc467c955a052f07b1424d75d1249ae33324dd870da35940bd6fbf313
-size 6363
+oid sha256:b44fc38d83678facad00d197ef1bca6a1f6590c889340310809b1ab991a4c752
+size 6364

indexes/vector_chunks.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:06da2c40c46e1ee695908f8e4d21ea1f96d47624cb256749a2503c6ae027e51f
-size 18088
+oid sha256:bb03df067944ceebdb682c0bca927a9ad12ac15d8967946fbcc027e731bcfc24
+size 18051

manifest.json

@@ -19,7 +19,7 @@
     "b": 0.75,
     "title_weight": 5.0,
     "body_weight": 1.0,
-    "average_document_length": 11.223512336719883,
+    "average_document_length": 386.13324538258576,
     "tokenizer": "hf-graphrag-bm25-tokens/v1",
     "max_query_terms": 64,
     "posting_rows_per_record": 4096,
@@ -27,28 +27,28 @@
   },
   "counts": {
     "bm25_document_chunks": 1,
-    "bm25_documents": 689,
-    "bm25_keyword_shards": 1,
-    "bm25_posting_rows": 739,
-    "bm25_postings": 4645,
-    "bm25_terms": 739,
+    "bm25_documents": 758,
+    "bm25_keyword_shards": 4,
+    "bm25_posting_rows": 15202,
+    "bm25_postings": 33741,
+    "bm25_terms": 15202,
     "corpus_chunks": 1,
-    "corpus_rows": 689,
+    "corpus_rows": 758,
     "graph_edge_chunks": 0,
-    "graph_edges": 4823,
+    "graph_edges": 5306,
     "graph_incoming_adjacency_edges": 0,
     "graph_incoming_adjacency_rows": 0,
     "graph_incoming_adjacency_shards": 0,
     "graph_node_chunks": 0,
-    "graph_nodes": 822,
+    "graph_nodes": 975,
     "graph_outgoing_adjacency_edges": 0,
     "graph_outgoing_adjacency_rows": 0,
     "graph_outgoing_adjacency_shards": 0,
     "vector_chunks": 1,
-    "vector_rows": 689,
-    "n_laws": 0,
+    "vector_rows": 758,
+    "n_laws": 69,
     "n_articles": 689,
-    "bm25_token_instances": 7733
+    "bm25_token_instances": 292689
   },
   "parquet": {
     "compression": "zstd",
@@ -87,7 +87,7 @@
     "default_probe_centroids": 1,
     "centroid_count": 1,
     "shard_count": 1,
-    "n_vectors": 689,
+    "n_vectors": 758,
     "status": "embedded"
   },
   "canonical_fields": [
@@ -128,7 +128,7 @@
     "articles_sha256": "d460260fd482656ba74cbf76d56346cec6f4fd86ec0235f5fd495c5fa02e00f1",
     "n_laws_in": 69,
     "n_articles_in": 692,
-    "unit": "article",
+    "unit": "law+article",
     "article_law_coverage": 10.028985507246377,
     "sparse_article_fallback": false,
     "drops": {
@@ -147,7 +147,8 @@
       ]
     },
     "language_breakdown": {
-      "ar": 689
+      "ar": 753,
+      "en": 5
     },
     "quality_flags": {
       "articles_table_empty": false,
@@ -169,29 +170,41 @@
       "laws.eli non-null=0/69",
       "laws.language values=['ar', 'en']"
     ],
-    "n_out": 689,
+    "n_out": 758,
     "never_invented_legal_text": true,
-    "n_before_dedupe": 692,
+    "n_reconstructed_parents": 0,
+    "n_reconstructed_truncated": 0,
+    "n_reconstructed_stubs": 0,
+    "n_empty_parents_with_articles_not_reconstructed": 0,
+    "n_before_dedupe": 761,
+    "n_law_rows": 69,
+    "n_child_rows": 689,
+    "n_instruments": 69,
     "n_dropped_total": 3,
     "record_type_breakdown": {
-      "article": 689
+      "article": 689,
+      "law": 69
     },
     "jurisdiction_breakdown": {
-      "LY": 689
+      "LY": 758
     },
     "snapshot_dates": [
-      "2026-09-15"
+      "2026-09-15",
+      "2026-09-18"
     ],
     "heading_language_counts": {
-      "ar": 80
+      "ar": 143,
+      "en": 313,
+      "fr": 1,
+      "yo": 1
     },
-    "heading_language_majority": "ar",
+    "heading_language_majority": "en",
     "document_language_majority": "ar",
     "verification": {
       "schema_version": "country-laws-normalize-verify/v1",
       "slug": "",
       "admitted": true,
-      "n_checks": 7,
+      "n_checks": 10,
       "n_failed": 0,
       "failed_ids": [],
       "checks": [
@@ -201,7 +214,7 @@
           "passed": true,
           "message": "normalized corpus has rows",
           "evidence": {
-            "n_out": 689,
+            "n_out": 758,
             "n_dropped": 3
           }
         },
@@ -231,10 +244,13 @@
           "passed": true,
           "message": "HTML tags stripped from legal bodies",
           "evidence": {
-            "n_bodies": 689,
-            "n_with_tags": 0,
-            "fraction": 0.0,
-            "samples": []
+            "n_bodies": 758,
+            "n_with_tags": 2,
+            "fraction": 0.002638522427440633,
+            "samples": [
+              "BT /F1 14.000 Tf ET\n%PDF-1.4\n%\n0.000 G\n1.000 g\n/GS1 gs\n0.567 w\n0 Tr\n[] 0 d\n3 0 obj\n<>\n/Contents 4 0 R>>\nendobj\n4 0 obj\n<",
+              "BT /F1 14.000 Tf ET\n%PDF-1.4\n%\n0.000 G\n1.000 g\n/GS1 gs\n0.567 w\n0 Tr\n[] 0 d\n3 0 obj\n<>\n/Contents 4 0 R>>\nendobj\n4 0 obj\n<"
+            ]
           }
         },
         {
@@ -244,31 +260,64 @@
           "message": "most legal units have usable body length",
           "evidence": {
             "n_short": 3,
-            "n_bodies": 689,
-            "fraction": 0.0043541364296081275
+            "n_bodies": 758,
+            "fraction": 0.00395778364116095
+          }
+        },
+        {
+          "id": "parent_laws",
+          "severity": "warn",
+          "passed": true,
+          "message": "parent instruments present (69 law rows from 69 source laws)",
+          "evidence": {
+            "n_laws_in": 69,
+            "n_law_rows": 69
+          }
+        },
+        {
+          "id": "reconstruction_grounded",
+          "severity": "fail",
+          "passed": true,
+          "message": "reconstructed parents match child glue",
+          "evidence": {
+            "checked": 0,
+            "mismatches": 0,
+            "samples": []
+          }
+        },
+        {
+          "id": "empty_parents_with_articles",
+          "severity": "fail",
+          "passed": true,
+          "message": "eligible empty parents all have law rows",
+          "evidence": {
+            "n_empty_parents_with_articles_not_reconstructed": 0
           }
         },
         {
           "id": "legal_structure",
           "severity": "warn",
           "passed": true,
-          "message": "retrieval units are structured (article, coverage=1.00)",
+          "message": "retrieval units are structured (law+article, coverage=0.91)",
           "evidence": {
-            "unit": "article",
+            "unit": "law+article",
             "structured_rows": 689,
-            "coverage": 1.0
+            "coverage": 0.9089709762532981
           }
         },
         {
           "id": "heading_language",
           "severity": "warn",
           "passed": true,
-          "message": "heading lexicon ar vs document language ar",
+          "message": "heading lexicon majority is en but documents are ar; review samples before trusting structure",
           "evidence": {
             "document_language": "ar",
-            "heading_language": "ar",
+            "heading_language": "en",
             "heading_counts": {
-              "ar": 80
+              "ar": 143,
+              "en": 313,
+              "fr": 1,
+              "yo": 1
             }
           }
         }
@@ -306,27 +355,27 @@
   },
   "indexes": {
     "bm25_document_chunks": {
-      "cid": "bafkreieocz43axc3lvbhbpyl5uh2fzk3pds3bcgkoemip2jjjue52ccsp4",
-      "sha256": "8e1679b05c5b5d4270bf0bed0fa2e55b78e5b088ca711887e9294d09dd08527f",
-      "size_bytes": 4578,
+      "cid": "bafkreiasdkr2bulfgyvsyjh6sy5d7wcmk5hu3jpuz7xqjftzg72mqx255i",
+      "sha256": "121aa3a0d165362b2c24fe963a3fd84c574f4da5f4cfef04967937f4c85f5dea",
+      "size_bytes": 4577,
       "relative_path": "indexes/bm25_document_chunks.parquet"
     },
     "bm25_keyword_shards": {
-      "cid": "bafkreia5wkjn6fexeyhthsdxkdg3r276c224ohw4bozjig2eulhpapmd5y",
-      "sha256": "1db292df1497260f33c87750cdb8ebfe16b5c71edc0bb2941b44a2cef03d83ee",
-      "size_bytes": 4821,
+      "cid": "bafkreihisiogcl7ovj75xhlyamsurd5h2nhqolegkywmfmd5g6pv7vk4ga",
+      "sha256": "e8921c612feeaa7fdb9d780325488fa7d34f072c86562cc2b07d379f5fd55c30",
+      "size_bytes": 5215,
       "relative_path": "indexes/bm25_keyword_shards.parquet"
     },
     "corpus_chunks": {
-      "cid": "bafkreiet5gp3uxoagjn4fr4cpliip7lmovak4qdet4moe54ca4wwahyu5a",
-      "sha256": "93e99fba5dc0325bc2c7827ad087fd6c7540ae40649f18e27782072d601f14e8",
+      "cid": "bafkreigsb4orxdcja5bi4y34z5oty4boiboffqgknegsn7yfnwheu7xj5i",
+      "sha256": "d20f1d1b8c4907428e637ccf5d3c702e405c52c0ca690d26ff056d8e4a7ee9ea",
       "size_bytes": 8604,
       "relative_path": "indexes/corpus_chunks.parquet"
     },
     "graph_edge_chunks": {
-      "cid": "bafkreiccztm5g6nf4s3rzv3u5ompczxd4367zin3ulxbpkrdrsi7anzvsu",
-      "sha256": "42ccd9d379a5e4b71cd774eb98f166e3e6fdfca1bba2ee17aa238c91f0373595",
-      "size_bytes": 5008,
+      "cid": "bafkreiduwogamxenh7god4em73hum3nrmaenr5dbwxfrbwmxp57n4ohxti",
+      "sha256": "74b38c065c8d3fcce1f08cfecf466db16008d8f461b5cb10d9977f7ede38f79a",
+      "size_bytes": 5001,
       "relative_path": "indexes/graph_edge_chunks.parquet"
     },
     "graph_incoming_adjacency": {
@@ -334,8 +383,8 @@
       "present": false
     },
     "graph_node_chunks": {
-      "cid": "bafkreiei2uz3hyu5mn2m56zvt7t6hf77qood4jx57xehveg6cg3xvjd2wy",
-      "sha256": "88d533b3e29d6374cefb359fe7e397ff839c3e26fdfdc87a90de11b77aa47ab6",
+      "cid": "bafkreibpk5shhxmp3eqt2p6cl467h7cylzknf7xdk67zhvpxec476agycq",
+      "sha256": "2f576473dd8fd9213d3fc25f3df3fc585e54d2fee357bf93d5f720b9ff00d814",
       "size_bytes": 4768,
       "relative_path": "indexes/graph_node_chunks.parquet"
     },
@@ -344,9 +393,9 @@
       "present": false
     },
     "vector_chunks": {
-      "cid": "bafkreiag3iwebrdod3tjleeprzgsd2q7s3khmjglevtutisqhrvoaj7fd4",
-      "sha256": "06da2c40c46e1ee695908f8e4d21ea1f96d47624cb256749a2503c6ae027e51f",
-      "size_bytes": 18088,
+      "cid": "bafkreif3appqm6kez3v5w2bmbpfje6u22evmcxmjm6kg7pgae7ttdph4eq",
+      "sha256": "bb03df067944ceebdb682c0bca927a9ad12ac15d8967946fbcc027e731bcfc24",
+      "size_bytes": 18051,
       "relative_path": "indexes/vector_chunks.parquet"
     }
   },
@@ -407,14 +456,24 @@
     "source_fingerprint": "d46fc6a85eaa4d39efa4aa66c1d6c284a5ab6447|287c69f712386f9e5d5d17e84c0934b40fcfabbef472d6a49b90cae303d44253|d460260fd482656ba74cbf76d56346cec6f4fd86ec0235f5fd495c5fa02e00f1",
     "prior_fingerprint": "d46fc6a85eaa4d39efa4aa66c1d6c284a5ab6447|287c69f712386f9e5d5d17e84c0934b40fcfabbef472d6a49b90cae303d44253|d460260fd482656ba74cbf76d56346cec6f4fd86ec0235f5fd495c5fa02e00f1",
     "delta": {
-      "n_added": 689,
+      "n_added": 758,
       "n_removed": 689,
       "n_unchanged": 0,
       "prior_count": 689,
-      "current_count": 689,
+      "current_count": 758,
       "changed_ratio": 1.0,
       "equivalent_to_full": true,
       "added_cids_sample": [
+        "bafkreia23jn7focwfdfnn6zkoz7w2elyf4lnksigofgqojl2cqmld64kpy",
+        "bafkreia2hozpc7hd7zodmunrotupps4yisul5iejytnpmxlsicls2ftsby",
+        "bafkreia2s6iozrqctijdtxnuukv3ektqv37kxmh6is3it3tegh7uq25mnq",
+        "bafkreia2vf3p72sqrbyv2gmefrpzshy55vnauukhlobzeiqpcyidp7vsba",
+        "bafkreia35s5t3hw6v3ihl746epvoogxmmez7bsabkt2cblfnqaty7ggd3i",
+        "bafkreia3sulwqm6pzgqdxm25mca4dq4rzzrcjefjwhmca54n47gm5cisli",
+        "bafkreia3vyreiyzrkxlahmerfeehfcihuw23oslm4lrmnnowveds32yro4",
+        "bafkreia4lljar3iniesc7jtspnlwr2bhvxvunxww2v5dgzabrkzj3evnzq"
+      ],
+      "removed_cids_sample": [
         "bafkreia2pq4n4el7jdhtl4eemh6hywju4pccmzixncjvue7pymh6ynpdrm",
         "bafkreia2r7ff53jw5tyr7u5waob5bj23hegjxotq7wpk53ej7xakddgosm",
         "bafkreia2r7ixien6w7wyhvzy6d3kq36bqxyura7tnypa4bhxq3l5x6f7qu",
@@ -423,16 +482,6 @@
         "bafkreia4cvhz4ngcaqup7tswr4sawiinymvt73odugpojmhdf522bqkx5e",
         "bafkreia4qdfvaotudqjacl3tzyspy2sowxiwjyvoao5jj6ffxwsikvzrzq",
         "bafkreia4slsmnhhrq2fx3bj5svedcszqv2lub2w25rpznwziyzrrnr7z5m"
-      ],
-      "removed_cids_sample": [
-        "bafkreia25ulmulpztpvrza4ohaso4lo2jnl6is3x752gva2bpts6n7auzu",
-        "bafkreia2avmoh5ffxow6ddanvolhupsygttsb62nlqzeev4nohty7dn45a",
-        "bafkreia2pwr6gfdytfh7lkp7uaag23usk6ii3mk6lkmytjgmcu3t6mgwpi",
-        "bafkreia2qyj3vmcptekj3dym3nuafjvpza577hmuuqsz2bquejccob3mui",
-        "bafkreia2xygqodfzxea5issedym7ri2xyfomyeu265wx3chhdw6nhzine4",
-        "bafkreia2ygsswntklxsskfrhxjit72epnok76unpda5yvglzzdzarqouoq",
-        "bafkreia36q665ghcpoqlzw6ichuxglkzzqjpmif4yp5ksz3voszyga4j4y",
-        "bafkreia46r4ne4jywa57czplvprne3uxn4avtg6ze2emxf6tnie3torwt4"
       ]
     },
     "reuse_embeddings": false,
@@ -440,9 +489,9 @@
     "equivalent_to_full": true,
     "schema_version": "country-laws-ir-graphrag/v1",
     "vectors": {
-      "n_docs": 689,
+      "n_docs": 758,
       "n_reused": 0,
-      "n_encoded": 689,
+      "n_encoded": 758,
       "n_missing": 0,
       "model_name": "thenlper/gte-small",
       "model_revision": "17e1f347d17fe144873b1201da91788898c639cd",
@@ -457,7 +506,7 @@
     "schema_version": "country-laws-ir-graphrag/v1",
     "bm25": {
       "bm25": {
-        "average_document_length": 11.223512336719883,
+        "average_document_length": 386.13324538258576,
         "b": 0.75,
         "body_weight": 1.0,
         "k1": 1.2,
@@ -474,34 +523,34 @@
       },
       "counts": {
         "bm25_document_chunks": 1,
-        "bm25_documents": 689,
-        "bm25_keyword_shards": 1,
-        "bm25_posting_rows": 739,
-        "bm25_postings": 4645,
-        "bm25_terms": 739,
-        "bm25_token_instances": 7733
+        "bm25_documents": 758,
+        "bm25_keyword_shards": 4,
+        "bm25_posting_rows": 15202,
+        "bm25_postings": 33741,
+        "bm25_terms": 15202,
+        "bm25_token_instances": 292689
       },
       "indexes": {
         "bm25_document_chunks": {
-          "cid": "bafkreieocz43axc3lvbhbpyl5uh2fzk3pds3bcgkoemip2jjjue52ccsp4",
+          "cid": "bafkreiasdkr2bulfgyvsyjh6sy5d7wcmk5hu3jpuz7xqjftzg72mqx255i",
           "relative_path": "indexes/bm25_document_chunks.parquet",
           "row_count": 1,
-          "sha256": "8e1679b05c5b5d4270bf0bed0fa2e55b78e5b088ca711887e9294d09dd08527f",
-          "size_bytes": 4578
+          "sha256": "121aa3a0d165362b2c24fe963a3fd84c574f4da5f4cfef04967937f4c85f5dea",
+          "size_bytes": 4577
         },
         "bm25_keyword_shards": {
-          "cid": "bafkreia5wkjn6fexeyhthsdxkdg3r276c224ohw4bozjig2eulhpapmd5y",
+          "cid": "bafkreihisiogcl7ovj75xhlyamsurd5h2nhqolegkywmfmd5g6pv7vk4ga",
           "relative_path": "indexes/bm25_keyword_shards.parquet",
-          "row_count": 1,
-          "sha256": "1db292df1497260f33c87750cdb8ebfe16b5c71edc0bb2941b44a2cef03d83ee",
-          "size_bytes": 4821
+          "row_count": 4,
+          "sha256": "e8921c612feeaa7fdb9d780325488fa7d34f072c86562cc2b07d379f5fd55c30",
+          "size_bytes": 5215
         }
       },
       "schema_version": "hf-graphrag-bm25-layout/v1"
     },
     "graph": {
-      "node_count": 822,
-      "edge_count": 4823,
+      "node_count": 975,
+      "edge_count": 5306,
       "adjacency": "data/graph/adjacency/{out,in}/*.parquet"
     },
     "sqlite": false,

normalization_report.json

@@ -5,7 +5,7 @@
   "articles_sha256": "d460260fd482656ba74cbf76d56346cec6f4fd86ec0235f5fd495c5fa02e00f1",
   "n_laws_in": 69,
   "n_articles_in": 692,
-  "unit": "article",
+  "unit": "law+article",
   "article_law_coverage": 10.028985507246377,
   "sparse_article_fallback": false,
   "drops": {
@@ -24,7 +24,8 @@
     ]
   },
   "language_breakdown": {
-    "ar": 689
+    "ar": 753,
+    "en": 5
   },
   "quality_flags": {
     "articles_table_empty": false,
@@ -46,29 +47,41 @@
     "laws.eli non-null=0/69",
     "laws.language values=['ar', 'en']"
   ],
-  "n_out": 689,
+  "n_out": 758,
   "never_invented_legal_text": true,
-  "n_before_dedupe": 692,
+  "n_reconstructed_parents": 0,
+  "n_reconstructed_truncated": 0,
+  "n_reconstructed_stubs": 0,
+  "n_empty_parents_with_articles_not_reconstructed": 0,
+  "n_before_dedupe": 761,
+  "n_law_rows": 69,
+  "n_child_rows": 689,
+  "n_instruments": 69,
   "n_dropped_total": 3,
   "record_type_breakdown": {
-    "article": 689
+    "article": 689,
+    "law": 69
   },
   "jurisdiction_breakdown": {
-    "LY": 689
+    "LY": 758
   },
   "snapshot_dates": [
-    "2026-09-15"
+    "2026-09-15",
+    "2026-09-18"
   ],
   "heading_language_counts": {
-    "ar": 80
+    "ar": 143,
+    "en": 313,
+    "fr": 1,
+    "yo": 1
   },
-  "heading_language_majority": "ar",
+  "heading_language_majority": "en",
   "document_language_majority": "ar",
   "verification": {
     "schema_version": "country-laws-normalize-verify/v1",
     "slug": "",
     "admitted": true,
-    "n_checks": 7,
+    "n_checks": 10,
     "n_failed": 0,
     "failed_ids": [],
     "checks": [
@@ -78,7 +91,7 @@
         "passed": true,
         "message": "normalized corpus has rows",
         "evidence": {
-          "n_out": 689,
+          "n_out": 758,
           "n_dropped": 3
         }
       },
@@ -108,10 +121,13 @@
         "passed": true,
         "message": "HTML tags stripped from legal bodies",
         "evidence": {
-          "n_bodies": 689,
-          "n_with_tags": 0,
-          "fraction": 0.0,
-          "samples": []
+          "n_bodies": 758,
+          "n_with_tags": 2,
+          "fraction": 0.002638522427440633,
+          "samples": [
+            "BT /F1 14.000 Tf ET\n%PDF-1.4\n%\n0.000 G\n1.000 g\n/GS1 gs\n0.567 w\n0 Tr\n[] 0 d\n3 0 obj\n<>\n/Contents 4 0 R>>\nendobj\n4 0 obj\n<",
+            "BT /F1 14.000 Tf ET\n%PDF-1.4\n%\n0.000 G\n1.000 g\n/GS1 gs\n0.567 w\n0 Tr\n[] 0 d\n3 0 obj\n<>\n/Contents 4 0 R>>\nendobj\n4 0 obj\n<"
+          ]
         }
       },
       {
@@ -121,31 +137,64 @@
         "message": "most legal units have usable body length",
         "evidence": {
           "n_short": 3,
-          "n_bodies": 689,
-          "fraction": 0.0043541364296081275
+          "n_bodies": 758,
+          "fraction": 0.00395778364116095
+        }
+      },
+      {
+        "id": "parent_laws",
+        "severity": "warn",
+        "passed": true,
+        "message": "parent instruments present (69 law rows from 69 source laws)",
+        "evidence": {
+          "n_laws_in": 69,
+          "n_law_rows": 69
+        }
+      },
+      {
+        "id": "reconstruction_grounded",
+        "severity": "fail",
+        "passed": true,
+        "message": "reconstructed parents match child glue",
+        "evidence": {
+          "checked": 0,
+          "mismatches": 0,
+          "samples": []
+        }
+      },
+      {
+        "id": "empty_parents_with_articles",
+        "severity": "fail",
+        "passed": true,
+        "message": "eligible empty parents all have law rows",
+        "evidence": {
+          "n_empty_parents_with_articles_not_reconstructed": 0
         }
       },
       {
         "id": "legal_structure",
         "severity": "warn",
         "passed": true,
-        "message": "retrieval units are structured (article, coverage=1.00)",
+        "message": "retrieval units are structured (law+article, coverage=0.91)",
         "evidence": {
-          "unit": "article",
+          "unit": "law+article",
           "structured_rows": 689,
-          "coverage": 1.0
+          "coverage": 0.9089709762532981
         }
       },
       {
         "id": "heading_language",
         "severity": "warn",
         "passed": true,
-        "message": "heading lexicon ar vs document language ar",
+        "message": "heading lexicon majority is en but documents are ar; review samples before trusting structure",
         "evidence": {
           "document_language": "ar",
-          "heading_language": "ar",
+          "heading_language": "en",
           "heading_counts": {
-            "ar": 80
+            "ar": 143,
+            "en": 313,
+            "fr": 1,
+            "yo": 1
           }
         }
       }

normalize.py

@@ -24,6 +24,12 @@ from . import ENTRY_IDENTITY_SCHEMA, LAW_IDENTITY_SCHEMA, SCHEMA_VERSION
 from .auth import configure_hf, public_token
 from .cidutil import cid_of_json, sha256_file, sha256_hex
 from .schema import SchemaError, validate_articles, validate_laws
+from .reconstruct import (
+    article_sort_key,
+    parent_needs_reconstruct,
+    reconstruct_on,
+    reconstruct_parent,
+)
 from .structure import normalize_legal_text, split_structured_units
 
 COLLECTOR_DEFAULT = "endomorphosis/ipfs_datasets_py"
@@ -399,6 +405,34 @@ def _base_record(
     }
     if extra:
         rec.update(extra)
+    from .citations import assign_citation, citation_fields
+
+    slug = ""
+    if source_dataset.startswith("endomorphosis/ipfs_") and source_dataset.endswith("_laws"):
+        slug = source_dataset.split("ipfs_", 1)[1].removesuffix("_laws")
+    year = ""
+    if snapshot_date and len(snapshot_date) >= 4 and snapshot_date[:4].isdigit():
+        year = snapshot_date[:4]
+    extra = extra or {}
+    rec.update(
+        citation_fields(
+            assign_citation(
+                eli=str(rec.get("eli") or extra.get("eli") or ""),
+                official_identifier=str(
+                    rec.get("official_identifier") or extra.get("official_identifier") or ""
+                ),
+                identifier=str(rec.get("identifier") or extra.get("identifier") or ""),
+                instrument_title=instrument_title,
+                article_number=article_number,
+                section_number=str(extra.get("section_number") or ""),
+                record_type=record_type,
+                jurisdiction=jurisdiction,
+                country=str(extra.get("country") or ""),
+                slug=slug,
+                year=year,
+            )
+        )
+    )
     rec["entry_cid"] = _entry_cid(rec)
     rec["title_length"] = len(title_for_bm25)
     rec["body_length"] = len(body)
@@ -455,16 +489,137 @@ def build_corpus(
         "schema_surprises": list(source_meta.get("schema_surprises") or []),
         "n_out": 0,
         "never_invented_legal_text": True,
+        "n_reconstructed_parents": 0,
+        "n_reconstructed_truncated": 0,
+        "n_reconstructed_stubs": 0,
+        "n_empty_parents_with_articles_not_reconstructed": 0,
     }
 
     entries: list[dict[str, Any]] = []
+    slug = ""
+    if source_dataset.startswith("endomorphosis/ipfs_") and source_dataset.endswith("_laws"):
+        slug = source_dataset.split("ipfs_", 1)[1].removesuffix("_laws")
+
+    children_by_law: dict[str, list[dict[str, Any]]] = {}
+    if not articles_empty:
+        for _, row in articles.iterrows():
+            lid = _row_get(row, "law_id")
+            if not lid:
+                continue
+            children_by_law.setdefault(lid, []).append(
+                {
+                    "id": _row_get(row, "id"),
+                    "title": _row_get(row, "title"),
+                    "article_number": _row_get(row, "article_number"),
+                    "body": _row_get(row, "text"),
+                    "row": row,
+                }
+            )
+
+    reconstructed_ids: set[str] = set()
+    running_extra_bytes = 0
+
+    def _append_law_row(
+        instrument_id: str,
+        parent: dict[str, Any],
+        recon=None,
+    ) -> None:
+        body = parent["body"]
+        recon_extra: dict[str, Any] = {}
+        coverage = _coverage_from(
+            parent["row"],
+            parent["metadata"],
+            articles_empty=articles_empty,
+            sparse_fallback=sparse_fallback,
+        )
+        if recon is not None and recon.reconstructed_from_articles:
+            body = recon.body
+            recon_extra = recon.extra_fields()
+            coverage = f"{coverage}; reconstructed_from_articles"
+        if not body:
+            kids = children_by_law.get(instrument_id) or []
+            if kids:
+                report["n_empty_parents_with_articles_not_reconstructed"] += 1
+            report["drops"]["empty_body"] += 1
+            if len(report["drop_samples"]["empty_body"]) < 20:
+                report["drop_samples"]["empty_body"].append(instrument_id)
+            return
+        meta = parent["metadata"]
+        entries.append(
+            _base_record(
+                record_type="law",
+                source_dataset=source_dataset,
+                source_revision=source_revision,
+                instrument_id=instrument_id,
+                instrument_title=parent["instrument_title"],
+                law_cid=parent["law_cid"],
+                article_number="",
+                article_title="",
+                body=body,
+                jurisdiction=parent["jurisdiction"],
+                language=parent["language"],
+                source_url=parent["source_url"],
+                snapshot_date=_snapshot_date(parent["row"], meta, source_meta),
+                coverage=coverage,
+                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": "",
+                    "reconstructed_from_articles": False,
+                    **_hierarchy_fields(
+                        parent["instrument_title"], body, "", language=parent["language"]
+                    ),
+                    **recon_extra,
+                },
+            )
+        )
 
     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 instrument_id, parent in law_map.items():
+        kids = children_by_law.get(instrument_id) or []
+        recon = None
+        if reconstruct_on() and parent_needs_reconstruct(parent["body"], len(kids)):
+            recon = reconstruct_parent(
+                slug=slug,
+                parent_body=parent["body"],
+                parent_title=parent["instrument_title"],
+                children=[
+                    {
+                        "id": k["id"],
+                        "title": k["title"],
+                        "article_number": k["article_number"],
+                        "body": k["body"],
+                    }
+                    for k in kids
+                ],
+                running_extra_bytes=running_extra_bytes,
+                sha256_hex=sha256_hex,
+            )
+            running_extra_bytes += recon.extra_bytes
+            reconstructed_ids.add(instrument_id)
+            report["n_reconstructed_parents"] += 1
+            if recon.reconstruction_truncated:
+                report["n_reconstructed_truncated"] += 1
+            if recon.is_stub:
+                report["n_reconstructed_stubs"] += 1
+        _append_law_row(instrument_id, parent, recon)
+
+    emit_articles = use_articles or bool(reconstructed_ids)
+    skip_body_split = emit_articles
+
+    if emit_articles:
         for _, row in articles.iterrows():
             source_id = _row_get(row, "id")
             instrument_id = _row_get(row, "law_id")
@@ -521,13 +676,10 @@ def build_corpus(
                     },
                 )
             )
-    else:
+    elif not skip_body_split:
         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"]
             units = split_structured_units(body, language=parent["language"])
@@ -572,49 +724,11 @@ def build_corpus(
                             },
                         )
                     )
-                continue
-            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": "",
-                        **_hierarchy_fields(
-                            parent["instrument_title"], body, "", language=parent["language"]
-                        ),
-                    },
-                )
-            )
 
     entries.sort(
         key=lambda r: (
             r["instrument_id"],
-            r.get("article_number") or "",
-            r["source_id"],
+            article_sort_key(r.get("article_number") or "", r["source_id"]),
         )
     )
     n_before = len(entries)
@@ -639,6 +753,20 @@ def build_corpus(
         raise SchemaError("Duplicate entry_cid remained after dedupe")
     report["n_before_dedupe"] = n_before
     report["n_out"] = int(len(df))
+    if not df.empty and "record_type" in df.columns:
+        n_law_rows = int((df["record_type"] == "law").sum())
+        n_child_rows = int(df["record_type"].isin(["article", "section"]).sum())
+        report["n_law_rows"] = n_law_rows
+        report["n_child_rows"] = n_child_rows
+        report["n_instruments"] = int(df["instrument_id"].nunique()) if "instrument_id" in df.columns else n_law_rows
+        if n_law_rows and n_child_rows:
+            report["unit"] = (
+                "law+structured" if report.get("unit") == "structured" else "law+article"
+            )
+        elif n_law_rows:
+            report["unit"] = "law"
+        elif n_child_rows:
+            report["unit"] = "article"
     report["n_dropped_total"] = (
         report["drops"]["empty_body"]
         + report["drops"]["missing_instrument"]

query.py

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

reports/normalization.json

@@ -5,7 +5,7 @@
   "articles_sha256": "d460260fd482656ba74cbf76d56346cec6f4fd86ec0235f5fd495c5fa02e00f1",
   "n_laws_in": 69,
   "n_articles_in": 692,
-  "unit": "article",
+  "unit": "law+article",
   "article_law_coverage": 10.028985507246377,
   "sparse_article_fallback": false,
   "drops": {
@@ -24,7 +24,8 @@
     ]
   },
   "language_breakdown": {
-    "ar": 689
+    "ar": 753,
+    "en": 5
   },
   "quality_flags": {
     "articles_table_empty": false,
@@ -46,29 +47,41 @@
     "laws.eli non-null=0/69",
     "laws.language values=['ar', 'en']"
   ],
-  "n_out": 689,
+  "n_out": 758,
   "never_invented_legal_text": true,
-  "n_before_dedupe": 692,
+  "n_reconstructed_parents": 0,
+  "n_reconstructed_truncated": 0,
+  "n_reconstructed_stubs": 0,
+  "n_empty_parents_with_articles_not_reconstructed": 0,
+  "n_before_dedupe": 761,
+  "n_law_rows": 69,
+  "n_child_rows": 689,
+  "n_instruments": 69,
   "n_dropped_total": 3,
   "record_type_breakdown": {
-    "article": 689
+    "article": 689,
+    "law": 69
   },
   "jurisdiction_breakdown": {
-    "LY": 689
+    "LY": 758
   },
   "snapshot_dates": [
-    "2026-09-15"
+    "2026-09-15",
+    "2026-09-18"
   ],
   "heading_language_counts": {
-    "ar": 80
+    "ar": 143,
+    "en": 313,
+    "fr": 1,
+    "yo": 1
   },
-  "heading_language_majority": "ar",
+  "heading_language_majority": "en",
   "document_language_majority": "ar",
   "verification": {
     "schema_version": "country-laws-normalize-verify/v1",
     "slug": "",
     "admitted": true,
-    "n_checks": 7,
+    "n_checks": 10,
     "n_failed": 0,
     "failed_ids": [],
     "checks": [
@@ -78,7 +91,7 @@
         "passed": true,
         "message": "normalized corpus has rows",
         "evidence": {
-          "n_out": 689,
+          "n_out": 758,
           "n_dropped": 3
         }
       },
@@ -108,10 +121,13 @@
         "passed": true,
         "message": "HTML tags stripped from legal bodies",
         "evidence": {
-          "n_bodies": 689,
-          "n_with_tags": 0,
-          "fraction": 0.0,
-          "samples": []
+          "n_bodies": 758,
+          "n_with_tags": 2,
+          "fraction": 0.002638522427440633,
+          "samples": [
+            "BT /F1 14.000 Tf ET\n%PDF-1.4\n%\n0.000 G\n1.000 g\n/GS1 gs\n0.567 w\n0 Tr\n[] 0 d\n3 0 obj\n<>\n/Contents 4 0 R>>\nendobj\n4 0 obj\n<",
+            "BT /F1 14.000 Tf ET\n%PDF-1.4\n%\n0.000 G\n1.000 g\n/GS1 gs\n0.567 w\n0 Tr\n[] 0 d\n3 0 obj\n<>\n/Contents 4 0 R>>\nendobj\n4 0 obj\n<"
+          ]
         }
       },
       {
@@ -121,31 +137,64 @@
         "message": "most legal units have usable body length",
         "evidence": {
           "n_short": 3,
-          "n_bodies": 689,
-          "fraction": 0.0043541364296081275
+          "n_bodies": 758,
+          "fraction": 0.00395778364116095
+        }
+      },
+      {
+        "id": "parent_laws",
+        "severity": "warn",
+        "passed": true,
+        "message": "parent instruments present (69 law rows from 69 source laws)",
+        "evidence": {
+          "n_laws_in": 69,
+          "n_law_rows": 69
+        }
+      },
+      {
+        "id": "reconstruction_grounded",
+        "severity": "fail",
+        "passed": true,
+        "message": "reconstructed parents match child glue",
+        "evidence": {
+          "checked": 0,
+          "mismatches": 0,
+          "samples": []
+        }
+      },
+      {
+        "id": "empty_parents_with_articles",
+        "severity": "fail",
+        "passed": true,
+        "message": "eligible empty parents all have law rows",
+        "evidence": {
+          "n_empty_parents_with_articles_not_reconstructed": 0
         }
       },
       {
         "id": "legal_structure",
         "severity": "warn",
         "passed": true,
-        "message": "retrieval units are structured (article, coverage=1.00)",
+        "message": "retrieval units are structured (law+article, coverage=0.91)",
         "evidence": {
-          "unit": "article",
+          "unit": "law+article",
           "structured_rows": 689,
-          "coverage": 1.0
+          "coverage": 0.9089709762532981
         }
       },
       {
         "id": "heading_language",
         "severity": "warn",
         "passed": true,
-        "message": "heading lexicon ar vs document language ar",
+        "message": "heading lexicon majority is en but documents are ar; review samples before trusting structure",
         "evidence": {
           "document_language": "ar",
-          "heading_language": "ar",
+          "heading_language": "en",
           "heading_counts": {
-            "ar": 80
+            "ar": 143,
+            "en": 313,
+            "fr": 1,
+            "yo": 1
           }
         }
       }