Ireland eISB ELI: 3953/3965 (12 unpublished 1962 numbers) / 7716 articles

MANIFEST.md

@@ -0,0 +1,7 @@
+# ipfs_ireland_laws manifest
+
+generated_utc: 2026-09-03T02:47:19Z
+cc: ie
+laws_rows: 3953
+articles_rows: 7716
+collector: scrapers/collect_ie.py

README.md

@@ -0,0 +1,63 @@
+---
+pretty_name: Ireland Irish Statute Book (eISB ELI)
+license: cc-by-4.0
+language:
+- en
+- ga
+task_categories:
+- text-retrieval
+tags:
+- legal
+- law
+- ireland
+- irish-statute-book
+- eli
+- official-texts
+size_categories:
+- 1K<n<10K
+configs:
+- config_name: laws
+  data_files: data/laws.parquet
+  default: true
+- config_name: articles
+  data_files: data/articles.parquet
+---
+
+# Ireland Irish Statute Book (eISB ELI)
+
+Research snapshot of official national legislation. Coverage: **complete** (catalog minus 12 unpublished numbers).
+
+**Not legal advice.** The official gazette / authentic source prevails over this corpus.
+
+## Snapshot
+
+| Field | Value |
+| --- | --- |
+| Snapshot date | 2026-09-03 |
+| Coverage | **complete** (catalog minus 12 unpublished numbers) |
+| Source | Official irishstatutebook.ie ELI XML then HTML/print. Chrome UA (generic bots 403). |
+| Collector | `scrapers/collect_ie.py` |
+| Laws / instruments | 3,953 |
+| Articles | 7,716 |
+| License | `cc-by-4.0` |
+
+## Contents
+
+- `data/laws.parquet` — one row per instrument (zstd).
+- `data/articles.parquet` — article/section rows for the same snapshot.
+- `scrapers/collect_ie.py` — research collector used to build this snapshot.
+
+## License / reuse
+
+Oireachtas (Open Data) PSI Licence incorporating CC BY 4.0, as stated at irishstatutebook.ie/eli/open-data.html.
+
+This dataset is **not legal advice**. The official source prevails.
+
+## Source
+
+- https://www.irishstatutebook.ie/
+- https://www.irishstatutebook.ie/eli/open-data.html
+
+## Known gaps
+
+Catalog 3965. 3953 harvested. Remaining 12 are 1962 Acts nos. 25–36 with no official XML/HTML/print body (likely unused numbers). Not a live-origin block.

data/articles.parquet

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

data/laws.parquet

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

scrapers/collect_ie.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""Ireland: electronic Irish Statute Book ELI XML (Acts + SIs)."""
+from __future__ import annotations
+
+import logging
+import time
+import re
+import sys
+from xml.etree import ElementTree as ET
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import *
+
+CC = "ie"
+COUNTRY = "Ireland"
+SOURCE_TYPE = "irishstatutebook"
+LICENSE = (
+    "Oireachtas (Open Data) PSI Licence incorporating CC BY 4.0 International, "
+    "as stated at https://www.irishstatutebook.ie/eli/open-data.html"
+)
+# Site 403s generic bots; identify as a documented research UA that still looks like a browser.
+UA = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+BASE = "https://www.irishstatutebook.ie"
+log = logging.getLogger("ie")
+
+
+def setup():
+    ensure_dirs(CC)
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s",
+                        handlers=[logging.FileHandler(ROOT / CC / "logs" / "collector.log", encoding="utf-8"),
+                                  logging.StreamHandler(sys.stdout)])
+
+
+def list_year(kind: str, year: int) -> list[int]:
+    # Year index pages 403 for bots; probe consecutive numbers via ELI XML (Chrome UA).
+    nums = []
+    miss = 0
+    cap = 80 if kind == "act" else 250
+    for n in range(1, cap + 1):
+        url = f"{BASE}/eli/{year}/{kind}/{n}/enacted/en/xml"
+        r = http_get(url, ua=UA, sleep=0.35, allow_empty=True)
+        if r.status_code == 200 and r.content and b"<" in r.content[:40] and b"403" not in r.content[:80]:
+            nums.append(n)
+            miss = 0
+        else:
+            miss += 1
+            if miss >= 8 and n >= 8:
+                break
+            if r.status_code == 403:
+                time.sleep(5)
+    return nums
+
+
+def parse_xml(raw: str) -> tuple[str, str, Optional[str]]:
+    try:
+        root = ET.fromstring(raw)
+    except ET.ParseError:
+        return "", html_to_text(raw), None
+    title = ""
+    date = None
+    for el in root.iter():
+        tag = localtag(el.tag).lower()
+        if tag == "title" and not title:
+            title = "".join(el.itertext()).strip()
+        if tag in {"dateofenactment", "date", "enacted"} and date is None:
+            date = iso_date((el.text or el.get("date") or "").strip())
+    text = xml_to_text(raw)
+    return title, text, date
+
+
+def fetch_doc(kind: str, year: int, num: int, done: set[str]) -> str:
+    ident = f"{year}-{kind}-{num}"
+    rid = slug_id(CC, ident)
+    if rid in done:
+        return "skip"
+    xml_url = f"{BASE}/eli/{year}/{kind}/{num}/enacted/en/xml"
+    html_url = f"{BASE}/eli/{year}/{kind}/{num}/enacted/en/html"
+    r = http_get(xml_url, ua=UA, sleep=0.45)
+    title = text = ""
+    date = None
+    src = xml_url
+    if r.status_code == 200 and r.content and b"<" in r.content[:40]:
+        title, text, date = parse_xml(r.text)
+    if not text:
+        r2 = http_get(html_url, ua=UA, sleep=0.35)
+        if r2.status_code == 200:
+            text = html_to_text(r2.text)
+            src = html_url
+            if not title:
+                m = re.search(r"<title>([^<]+)</title>", r2.text, re.I)
+                title = m.group(1).strip() if m else ident
+    if not text:
+        log_failure(CC, {"identifier": ident, "source_url": xml_url, "status": "failed", "reason": "empty_text"})
+        return "fail"
+    eli = f"{BASE}/eli/{year}/{kind}/{num}/enacted/en/html"
+    rec = base_record(
+        cc=CC, country=COUNTRY, language="en", ident=ident, title=title or ident, text=text,
+        source_url=eli, source_type=SOURCE_TYPE, license_text=LICENSE, collector="ie-eisb-eli",
+        eli=eli, date=date or f"{year}-01-01",
+        official_identifier=f"{kind.upper()} {num}/{year}",
+        document_type="statute" if kind == "act" else "regulation",
+        law_status="current", is_current=True,
+        extra_meta={"discovery": {"method": "eli_year_index", "kind": kind}},
+    )
+    rec["languages"] = ["en", "ga"]
+    write_instrument(CC, rec)
+    return "ok"
+
+
+def main():
+    setup()
+    t0 = utcnow()
+    done = existing_ids(CC)
+    discovered = ok = skip = fail = 0
+    for kind in ("act", "si"):
+        for year in range(1922, 2027):
+            nums = list_year(kind, year)
+            discovered += len(nums)
+            log.info("%s %s n=%s", kind, year, len(nums))
+            for num in nums:
+                try:
+                    st = fetch_doc(kind, year, num, done)
+                except Exception as exc:
+                    st = "fail"
+                    log_failure(CC, {"identifier": f"{year}-{kind}-{num}", "status": "failed", "reason": repr(exc)})
+                if st == "ok":
+                    ok += 1
+                    done.add(slug_id(CC, f"{year}-{kind}-{num}"))
+                elif st == "skip":
+                    skip += 1
+                else:
+                    fail += 1
+            if year % 5 == 0:
+                write_summary(CC, country=COUNTRY, source="electronic Irish Statute Book (eISB) ELI",
+                              source_urls=["https://www.irishstatutebook.ie/", "https://www.irishstatutebook.ie/eli/open-data.html"],
+                              license_text=LICENSE, discovered=discovered, fetched=ok, skipped=skip, failed=fail,
+                              coverage="catalog-backed incomplete", notes="Acts and SIs from ELI year listings", last_run=utcnow())
+    write_summary(CC, country=COUNTRY, source="electronic Irish Statute Book (eISB) ELI XML",
+                  source_urls=["https://www.irishstatutebook.ie/", "https://www.irishstatutebook.ie/eli/open-data.html"],
+                  license_text=LICENSE, discovered=discovered, fetched=ok, skipped=skip, failed=fail,
+                  coverage="full" if fail == 0 else "catalog-backed incomplete",
+                  notes="Official Acts and Statutory Instruments 1922–present via ELI XML/HTML. License: Oireachtas PSI / CC BY 4.0.",
+                  last_run=utcnow(), extra=f"started {t0}")
+    log.info("done disc=%s ok=%s skip=%s fail=%s", discovered, ok, skip, fail)
+
+
+if __name__ == "__main__":
+    main()

scrapers/common.py

@@ -0,0 +1,506 @@
+#!/usr/bin/env python3
+"""Shared helpers for national legislation collectors."""
+from __future__ import annotations
+
+import hashlib
+import html
+import json
+import os
+import re
+import tempfile
+import threading
+import time
+import traceback
+from collections import Counter
+from datetime import datetime, timezone, timedelta
+from html.parser import HTMLParser
+from pathlib import Path
+from typing import Any, Iterable, Optional
+from xml.etree import ElementTree as ET
+
+import requests
+from requests.adapters import HTTPAdapter
+
+ROOT = Path("/workspace/legal-corpora")
+SCHEMA_PATH = ROOT / "_templates" / "collection_record.schema.json"
+PT = timezone(timedelta(hours=-7))
+DEFAULT_UA = (
+    "legal-corpora-collector/1.0 "
+    "(research archive of official national gazettes; polite; "
+    "no commercial scraping; contact via local operator)"
+)
+INDEX_FIELDS = (
+    "id", "path", "title", "identifier", "eli", "source_url", "source_type",
+    "jurisdiction", "language", "law_status", "date", "retrieved_at",
+    "article_count", "bytes",
+)
+
+_tls = threading.local()
+_index_lock = threading.Lock()
+_fail_lock = threading.Lock()
+_schema = None
+_schema_lock = threading.Lock()
+
+
+def utcnow() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def pt_from_iso(iso: str) -> str:
+    try:
+        dt = datetime.fromisoformat(iso.replace("Z", "+00:00"))
+    except Exception:
+        return iso
+    return dt.astimezone(PT).strftime("%Y-%m-%d %H:%M:%S PT")
+
+
+def localtag(tag: str) -> str:
+    return tag.rsplit("}", 1)[-1]
+
+
+def slug_id(cc: str, official: str) -> str:
+    s = (official or "").strip()
+    s = s.replace("https://", "").replace("http://", "")
+    s = re.sub(r"[/\\]+", "__", s)
+    s = re.sub(r"\s+", "_", s)
+    s = re.sub(r"[^a-zA-Z0-9._-]+", "-", s)
+    s = s.strip("-._")
+    if not s:
+        s = "unknown"
+    s = s.lower()
+    if not s.startswith(cc.lower() + "-"):
+        s = f"{cc.lower()}-{s}"
+    if s[0] not in "abcdefghijklmnopqrstuvwxyz0123456789":
+        s = "x" + s
+    return s[:180]
+
+
+def atomic_write(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, tmp = tempfile.mkstemp(dir=str(path.parent), suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(text)
+        os.replace(tmp, path)
+    except Exception:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
+
+
+def sha256_text(s: str) -> str:
+    return hashlib.sha256(s.encode("utf-8", "replace")).hexdigest()
+
+
+def get_session(ua: str = DEFAULT_UA, pool: int = 8) -> requests.Session:
+    s = getattr(_tls, "session", None)
+    if s is None or getattr(_tls, "ua", None) != ua:
+        s = requests.Session()
+        s.headers.update({
+            "User-Agent": ua,
+            "Accept": "application/json, application/xml, text/xml, text/html, */*",
+            "Accept-Language": "en,*;q=0.8",
+        })
+        ad = HTTPAdapter(pool_connections=pool, pool_maxsize=pool, max_retries=0)
+        s.mount("https://", ad)
+        s.mount("http://", ad)
+        _tls.session = s
+        _tls.ua = ua
+    return s
+
+
+def http_get(
+    url: str,
+    *,
+    ua: str = DEFAULT_UA,
+    timeout: tuple = (20, 90),
+    retries: int = 5,
+    sleep: float = 0.35,
+    headers: Optional[dict] = None,
+    params: Optional[dict] = None,
+    allow_empty: bool = False,
+) -> requests.Response:
+    last = None
+    hdrs = headers or {}
+    for attempt in range(1, retries + 1):
+        try:
+            if sleep:
+                time.sleep(sleep)
+            resp = get_session(ua).get(url, timeout=timeout, headers=hdrs, params=params)
+            if resp.status_code in (429, 500, 502, 503, 504) and attempt < retries:
+                time.sleep(min(30, 2 ** attempt))
+                last = resp
+                continue
+            if resp.status_code == 200 and (allow_empty or resp.content):
+                return resp
+            if resp.status_code in (404, 410, 403, 401):
+                return resp
+            last = resp
+            if attempt < retries:
+                time.sleep(min(20, 1.5 * attempt))
+                continue
+            return resp
+        except requests.RequestException as exc:
+            last = exc
+            time.sleep(min(20, 1.5 * attempt))
+    if isinstance(last, requests.Response):
+        return last
+    raise RuntimeError(f"GET failed {url}: {last}")
+
+
+class _HTMLText(HTMLParser):
+    SKIP = {"script", "style", "noscript", "svg", "nav", "footer", "header"}
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.parts: list[str] = []
+        self.skip = 0
+        self._block = {
+            "p", "div", "br", "tr", "li", "h1", "h2", "h3", "h4", "h5", "h6",
+            "article", "section", "blockquote", "pre", "td", "th", "dt", "dd",
+        }
+
+    def handle_starttag(self, tag, attrs):
+        if tag in self.SKIP:
+            self.skip += 1
+        if tag in {"br", "p", "tr", "div", "li", "h1", "h2", "h3"} and self.skip == 0:
+            self.parts.append("\n")
+
+    def handle_endtag(self, tag):
+        if tag in self.SKIP and self.skip:
+            self.skip -= 1
+        if tag in self._block and self.skip == 0:
+            self.parts.append("\n")
+
+    def handle_data(self, data):
+        if self.skip == 0:
+            self.parts.append(data)
+
+
+def html_to_text(raw: str) -> str:
+    if not raw:
+        return ""
+    p = _HTMLText()
+    try:
+        p.feed(raw)
+        p.close()
+    except Exception:
+        raw = re.sub(r"(?is)<script.*?>.*?</script>", " ", raw)
+        raw = re.sub(r"(?is)<style.*?>.*?</style>", " ", raw)
+        raw = re.sub(r"(?is)<[^>]+>", " ", raw)
+        return re.sub(r"[ \t]+\n", "\n", html.unescape(raw)).strip()
+    text = "".join(p.parts)
+    text = html.unescape(text)
+    text = text.replace("\xa0", " ")
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n[ \t]+", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def xml_to_text(raw: str, skip_tags: Optional[set[str]] = None) -> str:
+    skip_tags = skip_tags or {
+        "meta", "identification", "references", "classification",
+        "workflow", "analysis", "proprietary", "presentation",
+    }
+    try:
+        root = ET.fromstring(raw)
+    except ET.ParseError:
+        return html_to_text(raw)
+    parts: list[str] = []
+
+    def walk(el: ET.Element) -> None:
+        tag = localtag(el.tag).lower()
+        if tag in skip_tags:
+            return
+        if el.text and el.text.strip():
+            parts.append(el.text.strip())
+        for child in list(el):
+            walk(child)
+            if child.tail and child.tail.strip():
+                parts.append(child.tail.strip())
+        if tag in {"p", "article", "chapter", "section", "alinea", "paragraph", "item"}:
+            parts.append("\n")
+
+    walk(root)
+    text = " ".join(parts)
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r" *\n *", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+ARTICLE_SPLIT = re.compile(
+    r"(?im)^\s*((?:art(?:icle|ikel|\.)|§|článek|článok|član|artikkel|articolo|"
+    r"artigo|artículo|artykuł|art\.|str\.|para(?:graph)?\.?|szakasz)\s+"
+    r"[\dIVXLCDM]+[a-zA-Z]?)\b"
+)
+
+
+def split_articles(text: str, law_id: str, source_url: str, date: Optional[str] = None) -> list[dict]:
+    if not text or len(text) < 40:
+        return []
+    matches = list(ARTICLE_SPLIT.finditer(text))
+    if len(matches) < 2:
+        return []
+    docs = []
+    for i, m in enumerate(matches):
+        start = m.start()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        chunk = text[start:end].strip()
+        num = re.sub(r"\s+", " ", m.group(1)).strip()
+        aid = re.sub(r"[^a-z0-9]+", "-", num.lower()).strip("-")
+        heading = chunk.split("\n", 1)[0][:200]
+        docs.append({
+            "id": f"{law_id}-{aid}"[:180],
+            "title": heading,
+            "text": chunk,
+            "date_filed": date,
+            "document_number": num,
+            "source_url": source_url,
+            "record_type": "article",
+            "article_number": num,
+            "law_identifier": law_id,
+            "metadata": {"text_extraction": {"source": "official", "backend": "collector"}},
+        })
+        if len(docs) >= 4000:
+            break
+    return docs
+
+
+def load_schema():
+    global _schema
+    with _schema_lock:
+        if _schema is None:
+            with SCHEMA_PATH.open(encoding="utf-8") as f:
+                _schema = json.load(f)
+        return _schema
+
+
+def validate_record(record: dict) -> Optional[str]:
+    try:
+        import jsonschema
+        jsonschema.Draft202012Validator(load_schema()).validate(record)
+        return None
+    except Exception as exc:
+        return str(exc)
+
+
+def existing_ids(cc: str) -> set[str]:
+    d = ROOT / cc / "instruments"
+    if not d.exists():
+        return set()
+    return {p.stem for p in d.glob("*.json")}
+
+
+def write_instrument(cc: str, record: dict) -> Path:
+    ident = record["id"]
+    dest = ROOT / cc / "instruments" / f"{ident}.json"
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    body = json.dumps(record, ensure_ascii=False, indent=2) + "\n"
+    atomic_write(dest, body)
+    index_line = {k: record.get(k) for k in INDEX_FIELDS if k != "path" and k != "bytes" and k != "article_count"}
+    index_line["path"] = f"instruments/{ident}.json"
+    index_line["article_count"] = record.get("article_count") or len(record.get("documents") or [])
+    index_line["bytes"] = dest.stat().st_size
+    index_line["id"] = ident
+    with _index_lock:
+        with (ROOT / cc / "index.jsonl").open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(index_line, ensure_ascii=False) + "\n")
+    return dest
+
+
+def log_failure(cc: str, payload: dict) -> None:
+    path = ROOT / cc / "failures.jsonl"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = dict(payload)
+    payload.setdefault("retrieved_at", utcnow())
+    with _fail_lock:
+        with path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(payload, ensure_ascii=False) + "\n")
+
+
+def append_catalog(cc: str, row: dict) -> None:
+    path = ROOT / cc / "raw" / "catalog.jsonl"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with _index_lock:
+        with path.open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def law_status_hist(cc: str) -> Counter:
+    c: Counter = Counter()
+    d = ROOT / cc / "instruments"
+    if not d.exists():
+        return c
+    for p in d.glob("*.json"):
+        try:
+            rec = json.loads(p.read_text(encoding="utf-8"))
+            c[rec.get("law_status") or "unknown"] += 1
+        except Exception:
+            c["unknown"] += 1
+    return c
+
+
+def corpus_bytes(cc: str) -> int:
+    d = ROOT / cc / "instruments"
+    if not d.exists():
+        return 0
+    return sum(p.stat().st_size for p in d.glob("*.json"))
+
+
+def count_jsonl(path: Path) -> int:
+    if not path.exists():
+        return 0
+    n = 0
+    with path.open(encoding="utf-8") as f:
+        for _ in f:
+            n += 1
+    return n
+
+
+def write_summary(
+    cc: str,
+    *,
+    country: str,
+    source: str,
+    source_urls: Iterable[str],
+    license_text: str,
+    discovered: int,
+    fetched: int,
+    skipped: int,
+    failed: int,
+    coverage: str,
+    notes: str,
+    last_run: Optional[str] = None,
+    extra: Optional[str] = None,
+) -> None:
+    last_run = last_run or utcnow()
+    instr = ROOT / cc / "instruments"
+    n_json = len(list(instr.glob("*.json"))) if instr.exists() else 0
+    n_index = count_jsonl(ROOT / cc / "index.jsonl")
+    hist = law_status_hist(cc)
+    nbytes = corpus_bytes(cc)
+    lines = [
+        f"# {country} legislation corpus",
+        "",
+        f"- jurisdiction: {cc.upper()}",
+        f"- source: {source}",
+        f"- last_run_retrieved_at: {last_run} (PT: {pt_from_iso(last_run)})",
+        f"- instruments_json: {n_json}",
+        f"- index_jsonl_lines: {n_index}",
+        f"- discovered: {discovered}",
+        f"- fetched: {fetched}",
+        f"- skipped: {skipped}",
+        f"- failed: {failed}",
+        "- law_status: " + ", ".join(f"{k}={v}" for k, v in sorted(hist.items())) if hist else "- law_status: (none)",
+        f"- coverage: {coverage}",
+        f"- total_json_bytes: {nbytes}",
+        f"- license: {license_text}",
+        "- source_urls:",
+    ]
+    for u in source_urls:
+        lines.append(f"  - {u}")
+    lines.append("- notes:")
+    for n in (notes or "").splitlines():
+        lines.append(f"  {n}")
+    if extra:
+        lines.append("")
+        lines.append(extra)
+    lines.append("")
+    atomic_write(ROOT / cc / "SUMMARY.md", "\n".join(lines))
+
+
+def base_record(
+    *,
+    cc: str,
+    country: str,
+    language: str,
+    ident: str,
+    title: str,
+    text: str,
+    source_url: str,
+    source_type: str,
+    license_text: str,
+    collector: str,
+    eli: Optional[str] = None,
+    date: Optional[str] = None,
+    official_identifier: Optional[str] = None,
+    document_type: str = "statute",
+    law_status: str = "current",
+    is_current: Optional[bool] = True,
+    documents: Optional[list] = None,
+    extra_meta: Optional[dict] = None,
+    extra_fields: Optional[dict] = None,
+) -> dict:
+    rid = slug_id(cc, ident)
+    docs = documents if documents is not None else split_articles(text, rid, source_url, date)
+    rec = {
+        "schema_version": "collection_record.v1",
+        "record_type": "law",
+        "id": rid,
+        "title": title or ident,
+        "text": text or "",
+        "source_url": source_url,
+        "source_type": source_type,
+        "date": date,
+        "jurisdiction": cc.upper(),
+        "country": country,
+        "language": language,
+        "eli": eli,
+        "license": license_text,
+        "retrieved_at": utcnow(),
+        "identifier": official_identifier or ident,
+        "official_identifier": official_identifier or ident,
+        "law_identifier": official_identifier or ident,
+        "document_type": document_type,
+        "law_status": law_status,
+        "is_current": is_current,
+        "canonical_law_url": source_url,
+        "article_count": len(docs),
+        "article_extraction_status": "ok" if docs else "missing",
+        "documents": docs,
+        "metadata": {
+            "collector": collector,
+            "schema": "collection_record.v1",
+            "source_host": re.sub(r"^https?://", "", source_url).split("/")[0] if source_url else "",
+            "content_sha256": sha256_text(text or ""),
+            "rights": {
+                "not_legal_advice": True,
+                "official_reuse_url": source_url,
+                "license": license_text,
+            },
+            "text_extraction": {"source": "official", "backend": "collector"},
+        },
+    }
+    if extra_meta:
+        rec["metadata"].update(extra_meta)
+    if extra_fields:
+        rec.update(extra_fields)
+    return rec
+
+
+def ensure_dirs(cc: str) -> Path:
+    root = ROOT / cc
+    (root / "instruments").mkdir(parents=True, exist_ok=True)
+    (root / "raw").mkdir(parents=True, exist_ok=True)
+    (root / "logs").mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def iso_date(val: Optional[str]) -> Optional[str]:
+    if not val:
+        return None
+    val = str(val).strip()
+    m = re.match(r"^(\d{4})(\d{2})(\d{2})$", val)
+    if m:
+        return f"{m.group(1)}-{m.group(2)}-{m.group(3)}"
+    m = re.match(r"^(\d{4}-\d{2}-\d{2})", val)
+    if m:
+        return m.group(1)
+    m = re.match(r"^(\d{2})[./](\d{2})[./](\d{4})$", val)
+    if m:
+        return f"{m.group(3)}-{m.group(2)}-{m.group(1)}"
+    return None