UAE federal: 237/237 Constitution+Federal Law+Decree-Law

MANIFEST.md

@@ -0,0 +1,21 @@
+# ipfs_uae_laws manifest
+
+generated_utc: 2026-09-03T02:50:08Z
+cc: ae
+country: United Arab Emirates
+laws_rows: 237
+articles_rows: 182
+laws_bytes: 2179256
+articles_bytes: 84017
+laws_sha256: b7aaf5bc972ec75f99379cb5e87eea144b7906286803d24c08f355ef0bd19698
+articles_sha256: edb2e03006dafa2c8acb32a332f9669428ff5fc1652954c534d130865b37d88b
+laws_parquet: /workspace/legal-corpora/hf-staging/ipfs_uae_laws/data/laws.parquet
+articles_parquet: /workspace/legal-corpora/hf-staging/ipfs_uae_laws/data/articles.parquet
+compression: zstd
+collector: scrapers/collect_ae.py
+license: Official UAE Legislation texts; authentic Official Gazette prevails; not legal advice.
+source: https://uaelegislation.gov.ae/
+gaps: |
+  Federal Law / Federal Decree-Law / Constitution from official uaelegislation.gov.ae list API and PDF downloads. Cabinet resolutions excluded. 429/403 uses archive_fallbacks of official URLs. Started 2026-09-03T02:41:24Z.
+  
+  started 2026-09-03T02:41:24Z

README.md

@@ -0,0 +1,67 @@
+---
+pretty_name: UAE Federal Laws and Constitution (UAE Legislation)
+license: other
+license_name: uae-legislation-terms
+language:
+- en
+task_categories:
+- text-retrieval
+tags:
+- legal
+- law
+- uae
+- uaelegislation
+- official-texts
+size_categories:
+- n<1K
+configs:
+- config_name: laws
+  data_files: data/laws.parquet
+  default: true
+- config_name: articles
+  data_files: data/articles.parquet
+---
+
+# UAE Federal Laws and Constitution (UAE Legislation)
+
+Research snapshot of official national legislation from **UAE Legislation (General Secretariat of the UAE Cabinet)**.
+
+**Not legal advice.** The official gazette / authentic source prevails over this corpus.
+
+## Snapshot
+
+| Field | Value |
+| --- | --- |
+| Snapshot date | 2026-09-03 |
+| Coverage | snapshot |
+| Source | UAE Legislation (General Secretariat of the UAE Cabinet) |
+| Collector | `scrapers/collect_ae.py` |
+| Laws / instruments | 237 |
+| Articles | 182 |
+| Language | en |
+| Jurisdiction | United Arab Emirates |
+| License | `uae-legislation-terms` |
+
+## Contents
+
+- `data/laws.parquet` — one row per instrument (LAW_FLAT, zstd).
+- `data/articles.parquet` — article/section rows for the same snapshot.
+- `scrapers/collect_ae.py` — research collector used to build this snapshot.
+
+## License / reuse
+
+Official UAE Legislation texts; authentic Official Gazette prevails; not legal advice.
+
+This dataset is **not legal advice**. The official source prevails.
+
+## Source
+
+- https://uaelegislation.gov.ae/
+
+## Known gaps
+
+Federal Law / Federal Decree-Law / Constitution. Not commercial compilations.
+
+Federal Law / Federal Decree-Law / Constitution from official uaelegislation.gov.ae list API and PDF downloads. Cabinet resolutions excluded. 429/403 uses archive_fallbacks of official URLs. Started 2026-09-03T02:41:24Z.
+
+started 2026-09-03T02:41:24Z

data/articles.parquet

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

data/laws.parquet

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

data/manifest.json

@@ -0,0 +1,14 @@
+{
+  "slug": "ipfs_uae_laws",
+  "cc": "ae",
+  "laws_rows": 237,
+  "articles_rows": 182,
+  "laws_bytes": 2179256,
+  "articles_bytes": 84017,
+  "laws_sha256": "b7aaf5bc972ec75f99379cb5e87eea144b7906286803d24c08f355ef0bd19698",
+  "articles_sha256": "edb2e03006dafa2c8acb32a332f9669428ff5fc1652954c534d130865b37d88b",
+  "compression": "zstd",
+  "collector": "collect_ae.py",
+  "license": "Official UAE Legislation texts; authentic Official Gazette prevails; not legal advice.",
+  "generated_utc": "2026-09-03T02:50:08Z"
+}

scrapers/archive_fallbacks.py

@@ -0,0 +1,626 @@
+#!/usr/bin/env python3
+"""Public Wayback CDX + Common Crawl CDX/WARC fetch (ipfs_datasets_py fallback intent).
+
+Does not import the full ipfs_datasets_py package. Matches:
+  search_wayback_machine / get_wayback_content (wayback_machine_engine.py)
+  Common Crawl CDX at https://index.commoncrawl.org/
+  archive.is newest lookup
+Brave Search is skipped when no API key is present.
+"""
+from __future__ import annotations
+
+import gzip
+import io
+import json
+import logging
+import os
+import re
+import time
+from typing import Any, Optional
+from urllib.parse import quote, urljoin, urlparse
+
+import requests
+from requests.adapters import HTTPAdapter
+
+log = logging.getLogger("archive_fallbacks")
+
+WAYBACK_CDX = "https://web.archive.org/cdx/search/cdx"
+WAYBACK_WEB = "https://web.archive.org/web"
+CC_COLLINFO = "https://index.commoncrawl.org/collinfo.json"
+CC_DATA = "https://data.commoncrawl.org"
+ARCHIVE_IS_NEWEST = "https://archive.is/newest/"
+ARCHIVE_PH_NEWEST = "https://archive.ph/newest/"
+
+UA = (
+    "legal-corpora-collector/1.0 "
+    "(research archive of official national gazettes; polite; "
+    "contact via local operator)"
+)
+
+CHALLENGE_RE = re.compile(
+    r"just\s+a\s+moment|cf-browser-verification|cloudflare|enable\s+javascript|"
+    r"you\s+need\s+to\s+enable\s+javascript|tspd_|bobcmn|attention\s+required|"
+    r"checking\s+your\s+browser|please\s+wait\s+while\s+we\s+verify|"
+    r"request\s+rejected|access\s+denied",
+    re.I,
+)
+SPA_SHELL_RE = re.compile(
+    r"<app-root[\s>]|ng-version=|outsystems-ui|data-block=\"MainContent\"|"
+    r"id=\"outsystems\"|window\.__INITIAL_STATE__\s*=\s*\{\s*\}",
+    re.I,
+)
+
+_session: Optional[requests.Session] = None
+_cc_indexes: Optional[list[str]] = None
+_cc_dead: set[str] = set()
+_last_wayback = 0.0
+_last_cc = 0.0
+
+
+def session() -> requests.Session:
+    global _session
+    if _session is None:
+        s = requests.Session()
+        s.headers.update({"User-Agent": UA, "Accept": "*/*"})
+        ad = HTTPAdapter(pool_connections=8, pool_maxsize=8, max_retries=0)
+        s.mount("https://", ad)
+        s.mount("http://", ad)
+        _session = s
+    return _session
+
+
+def _sleep_wayback(delay: float = 1.0) -> None:
+    global _last_wayback
+    now = time.time()
+    wait = delay - (now - _last_wayback)
+    if wait > 0:
+        time.sleep(wait)
+    _last_wayback = time.time()
+
+
+def _sleep_cc(delay: float = 0.35) -> None:
+    global _last_cc
+    now = time.time()
+    wait = delay - (now - _last_cc)
+    if wait > 0:
+        time.sleep(wait)
+    _last_cc = time.time()
+
+
+def has_brave_key() -> bool:
+    return bool(
+        (os.environ.get("BRAVE_API_KEY") or os.environ.get("BRAVE_SEARCH_API_KEY") or "").strip()
+    )
+
+
+def is_challenge(html: str, status: int = 200) -> bool:
+    if status in (401, 403, 429, 503):
+        return True
+    if not html:
+        return False
+    head = html[:8000]
+    if CHALLENGE_RE.search(head):
+        return True
+    if SPA_SHELL_RE.search(head) and len(html) < 8000:
+        return True
+    return False
+
+
+def is_spa_shell(html: str, text: str) -> bool:
+    if not html:
+        return False
+    if SPA_SHELL_RE.search(html[:12000]) and len(text or "") < 400:
+        return True
+    return False
+
+
+# --- Wayback ---
+
+CDX_PAGE = 200  # large single-shot limits (2000+) 504 on web.archive.org
+
+
+def _parse_cdx_json(data: Any, mime_prefix: Optional[str] = None) -> tuple[list[dict], Optional[str]]:
+    """Parse Wayback CDX JSON, including showResumeKey trailer."""
+    if not isinstance(data, list) or len(data) <= 1:
+        return [], None
+    resume = None
+    rows = data
+    # Trailer: ..., [], ["resumeKey"]
+    if len(data) >= 3 and data[-2] == [] and isinstance(data[-1], list) and data[-1]:
+        resume = str(data[-1][0]) if data[-1][0] else None
+        rows = data[:-2]
+    headers = rows[0] if rows else []
+    out: list[dict] = []
+    for row in rows[1:]:
+        if not row:
+            continue
+        rec = dict(zip(headers, row)) if headers and isinstance(headers[0], str) else {}
+        if not rec and isinstance(row, list) and len(row) >= 5:
+            rec = {
+                "urlkey": row[0],
+                "timestamp": row[1],
+                "original": row[2],
+                "mimetype": row[3],
+                "statuscode": row[4],
+                "digest": row[5] if len(row) > 5 else "",
+                "length": row[6] if len(row) > 6 else "0",
+            }
+        orig = rec.get("original") or rec.get("url") or ""
+        ts = rec.get("timestamp") or ""
+        mime = rec.get("mimetype") or ""
+        if mime_prefix and mime and not mime.lower().startswith(mime_prefix.lower()) and mime not in (
+            "application/pdf",
+            "application/xml",
+            "text/xml",
+            "application/xhtml+xml",
+            "text/html",
+            "application/json",
+        ):
+            continue
+        if not orig or not ts:
+            continue
+        rec["wayback_url"] = f"{WAYBACK_WEB}/{ts}id_/{orig}"
+        rec["source"] = "wayback"
+        out.append(rec)
+    return out, resume
+
+
+def _wayback_cdx_page(
+    url: str,
+    *,
+    limit: int,
+    collapse: str,
+    filter_status: str,
+    from_date: Optional[str],
+    to_date: Optional[str],
+    match_type: Optional[str],
+    extra_filters: Optional[list[str]],
+    resume_key: Optional[str],
+    mime_prefix: Optional[str],
+    page_size: int,
+) -> tuple[list[dict], Optional[str]]:
+    items: list[tuple[str, Any]] = [
+        ("url", url),
+        ("output", "json"),
+        ("fl", "urlkey,timestamp,original,mimetype,statuscode,digest,length"),
+        ("limit", int(page_size)),
+        ("showResumeKey", "true"),
+    ]
+    if collapse:
+        items.append(("collapse", collapse))
+    if from_date:
+        items.append(("from", from_date))
+    if to_date:
+        items.append(("to", to_date))
+    if match_type:
+        items.append(("matchType", match_type))
+    if filter_status:
+        items.append(("filter", f"statuscode:{filter_status}"))
+    for flt in extra_filters or []:
+        items.append(("filter", flt))
+    if resume_key:
+        items.append(("resumeKey", resume_key))
+    _sleep_wayback(1.0)
+    last_err = None
+    for attempt, psz in enumerate((page_size, 120, 80), 1):
+        if attempt > 1:
+            items = [(k, psz if k == "limit" else v) for k, v in items]
+            _sleep_wayback(1.5)
+        try:
+            r = session().get(WAYBACK_CDX, params=items, timeout=(20, 90))
+        except requests.RequestException as exc:
+            last_err = exc
+            log.warning("wayback cdx fail %s: %s", url, exc)
+            continue
+        if r.status_code in (502, 503, 504) or not r.content:
+            last_err = f"http_{r.status_code}"
+            log.info("wayback cdx HTTP %s for %s (page_size=%s)", r.status_code, url, psz)
+            continue
+        if r.status_code != 200:
+            log.info("wayback cdx HTTP %s for %s", r.status_code, url)
+            return [], None
+        try:
+            data = r.json()
+        except Exception:
+            return [], None
+        return _parse_cdx_json(data, mime_prefix=mime_prefix)
+    log.info("wayback cdx gave up %s last=%s", url, last_err)
+    return [], None
+
+
+def search_wayback_machine(
+    url: str,
+    *,
+    from_date: Optional[str] = None,
+    to_date: Optional[str] = None,
+    limit: int = 100,
+    collapse: str = "urlkey",
+    filter_status: str = "200",
+    match_type: Optional[str] = None,
+    mime_prefix: Optional[str] = None,
+    extra_filters: Optional[list[str]] = None,
+) -> list[dict]:
+    """CDX search with resumeKey pagination (single-shot limit>=2000 504s)."""
+    target = max(1, int(limit))
+    page_size = CDX_PAGE if target > CDX_PAGE else target
+    out: list[dict] = []
+    seen = set()
+    resume: Optional[str] = None
+    empty = 0
+    while len(out) < target:
+        need = min(page_size, target - len(out))
+        batch, resume = _wayback_cdx_page(
+            url,
+            limit=need,
+            collapse=collapse,
+            filter_status=filter_status,
+            from_date=from_date,
+            to_date=to_date,
+            match_type=match_type,
+            extra_filters=extra_filters,
+            resume_key=resume,
+            mime_prefix=mime_prefix,
+            page_size=need,
+        )
+        added = 0
+        for rec in batch:
+            key = (rec.get("original"), rec.get("timestamp"), rec.get("digest"))
+            if key in seen:
+                continue
+            seen.add(key)
+            out.append(rec)
+            added += 1
+        if added == 0:
+            empty += 1
+            if empty >= 2 or not resume:
+                break
+        else:
+            empty = 0
+        if not resume:
+            break
+        log.info("wayback cdx %s page n=%s total=%s/%s", url, added, len(out), target)
+    return out[:target]
+
+
+def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
+    """Fetch a snapshot; id_ modifier skips Wayback chrome. No CDX search."""
+    if timestamp:
+        wb = f"{WAYBACK_WEB}/{timestamp}id_/{url}"
+    else:
+        wb = f"{WAYBACK_WEB}/2id_/{url}"
+    r = None
+    last_err = None
+    for attempt in range(1, 5):
+        _sleep_wayback(1.2 if attempt == 1 else min(20.0, 2.5 * attempt))
+        try:
+            r = session().get(wb, timeout=(20, 90), allow_redirects=True)
+        except requests.RequestException as exc:
+            last_err = str(exc)
+            log.info("wayback replay fail %s: %s", url, exc)
+            continue
+        if r.status_code in (403, 429, 503, 502, 504) and attempt < 4:
+            log.info("wayback replay HTTP %s %s attempt=%s", r.status_code, url, attempt)
+            continue
+        break
+    if r is None:
+        return {"status": "error", "error": last_err or "no_response", "url": url}
+    cap_ts = timestamp or ""
+    m = re.search(r"/web/(\d{14})", r.url or "")
+    if m:
+        cap_ts = m.group(1)
+    ctype = r.headers.get("content-type") or ""
+    body = r.content or b""
+    text = ""
+    if "html" in ctype or "xml" in ctype or "text/" in ctype or not ctype:
+        enc = r.encoding or "utf-8"
+        try:
+            text = body.decode(enc, "replace")
+        except Exception:
+            text = body.decode("utf-8", "replace")
+    if r.status_code != 200 or not body:
+        return {
+            "status": "error",
+            "error": f"http_{r.status_code}",
+            "http_status": r.status_code,
+            "wayback_url": r.url,
+            "original_url": url,
+        }
+    if text and is_challenge(text, r.status_code):
+        return {
+            "status": "error",
+            "error": "challenge_or_shell",
+            "http_status": r.status_code,
+            "wayback_url": r.url,
+            "original_url": url,
+            "content": text[:2000],
+        }
+    return {
+        "status": "success",
+        "content": body,
+        "text": text,
+        "content_type": ctype,
+        "wayback_url": r.url,
+        "capture_timestamp": cap_ts,
+        "original_url": url,
+        "http_status": r.status_code,
+        "method": "wayback",
+    }
+
+
+# --- Common Crawl ---
+
+def cc_indexes(n: int = 6) -> list[str]:
+    global _cc_indexes
+    if _cc_indexes is None:
+        try:
+            r = session().get(CC_COLLINFO, timeout=30)
+            cols = r.json() if r.status_code == 200 else []
+            ids = []
+            for c in cols:
+                cid = c.get("id") or ""
+                cdx = c.get("cdx-api") or c.get("cdx_api") or ""
+                if cid:
+                    ids.append(cdx or f"https://index.commoncrawl.org/{cid}-index")
+            # collinfo is newest-first. Do not drop crawls that 404 a
+            # specific URL (that means "no captures", not a dead index).
+            _cc_indexes = ids or [
+                "https://index.commoncrawl.org/CC-MAIN-2025-18-index",
+                "https://index.commoncrawl.org/CC-MAIN-2024-33-index",
+            ]
+        except Exception as exc:
+            log.warning("cc collinfo: %s", exc)
+            _cc_indexes = [
+                "https://index.commoncrawl.org/CC-MAIN-2026-34-index",
+                "https://index.commoncrawl.org/CC-MAIN-2026-30-index",
+                "https://index.commoncrawl.org/CC-MAIN-2026-25-index",
+                "https://index.commoncrawl.org/CC-MAIN-2024-33-index",
+            ]
+    return _cc_indexes[:n]
+
+
+def search_common_crawl(url: str, *, limit: int = 80, indexes: Optional[list[str]] = None) -> list[dict]:
+    """Query public CC CDX (https://index.commoncrawl.org/).
+
+    Do not send filter=status:200 — on some shards that returns a false
+    404 "No Captures found". Filter status client-side instead.
+    HTTP 404 with that message means no hits in this crawl, not a dead index.
+    """
+    out = []
+    seen = set()
+    empty = 0
+    for idx in (indexes or cc_indexes(12)):
+        if idx in _cc_dead:
+            continue
+        params = {
+            "url": url,
+            "output": "json",
+            "limit": str(limit),
+        }
+        _sleep_cc(0.3)
+        try:
+            r = session().get(idx, params=params, timeout=(12, 25))
+        except requests.RequestException as exc:
+            log.info("cc cdx %s fail %s", idx, exc)
+            continue
+        if r.status_code == 404:
+            msg = (r.text or "")[:80]
+            log.info("cc cdx no-captures %s %s", idx.split("/")[-1], msg)
+            empty += 1
+            if empty >= 8 and not out:
+                continue
+            continue
+        if r.status_code in (410,):
+            _cc_dead.add(idx)
+            log.info("cc cdx dead HTTP %s %s", r.status_code, idx.split("/")[-1])
+            continue
+        if r.status_code != 200 or not r.content:
+            log.info("cc cdx HTTP %s %s", r.status_code, idx.split("/")[-1])
+            continue
+        for line in r.text.splitlines():
+            line = line.strip()
+            if not line or line[0] not in "{[":
+                continue
+            try:
+                rec = json.loads(line)
+            except Exception:
+                continue
+            orig = rec.get("url") or rec.get("original") or ""
+            st = str(rec.get("status") or rec.get("statuscode") or "200")
+            if st and st not in ("200", "201", "206"):
+                continue
+            key = (orig, rec.get("filename"), rec.get("offset"))
+            if not orig or key in seen:
+                continue
+            seen.add(key)
+            rec["original"] = orig
+            rec["source"] = "common_crawl"
+            rec["cc_index"] = idx
+            out.append(rec)
+        if out:
+            log.info("cc cdx %s hits=%s", idx.split("/")[-1], len(out))
+        if len(out) >= limit or out:
+            break
+    return out[:limit]
+
+
+def _parse_warc_http(raw: bytes) -> tuple[int, str, bytes]:
+    data = raw
+    if data[:2] == b"\x1f\x8b":
+        try:
+            data = gzip.decompress(data)
+        except Exception:
+            try:
+                data = gzip.GzipFile(fileobj=io.BytesIO(data)).read()
+            except Exception:
+                pass
+    # WARC record: headers, then HTTP payload
+    split = data.split(b"\r\n\r\n", 1)
+    if len(split) < 2:
+        return 0, "", data
+    warc_headers, rest = split
+    if rest.startswith(b"HTTP/") or rest.startswith(b"http/"):
+        http_split = rest.split(b"\r\n\r\n", 1)
+        http_head = http_split[0].decode("latin-1", "replace")
+        body = http_split[1] if len(http_split) > 1 else b""
+        m = re.search(r"HTTP/\d\.\d\s+(\d{3})", http_head)
+        status = int(m.group(1)) if m else 0
+        cm = re.search(r"Content-Type:\s*([^\r\n]+)", http_head, re.I)
+        ctype = cm.group(1).strip() if cm else ""
+        return status, ctype, body
+    return 0, "", rest
+
+
+def fetch_common_crawl_warc(rec: dict, max_bytes: int = 4_000_000) -> dict:
+    fn = rec.get("filename") or rec.get("warc_filename") or ""
+    try:
+        off = int(rec.get("offset") or rec.get("warc_offset") or 0)
+        ln = int(rec.get("length") or rec.get("warc_length") or 0)
+    except Exception:
+        return {"status": "error", "error": "bad_pointer"}
+    if not fn or ln <= 0:
+        return {"status": "error", "error": "missing_pointer"}
+    ln = min(ln, max_bytes)
+    url = fn if str(fn).startswith("http") else f"{CC_DATA}/{fn.lstrip('/')}"
+    _sleep_cc(0.25)
+    try:
+        r = session().get(
+            url,
+            headers={"Range": f"bytes={off}-{off + ln - 1}"},
+            timeout=(20, 90),
+        )
+    except requests.RequestException as exc:
+        return {"status": "error", "error": str(exc)}
+    if r.status_code not in (200, 206) or not r.content:
+        return {"status": "error", "error": f"http_{r.status_code}"}
+    status, ctype, body = _parse_warc_http(r.content)
+    text = ""
+    if body and (
+        "html" in (ctype or "")
+        or "xml" in (ctype or "")
+        or "text/" in (ctype or "")
+        or not ctype
+    ):
+        text = body.decode("utf-8", "replace")
+    orig = rec.get("original") or rec.get("url") or ""
+    if text and is_challenge(text, status or 200):
+        return {"status": "error", "error": "challenge_or_shell", "original_url": orig}
+    return {
+        "status": "success",
+        "content": body,
+        "text": text,
+        "content_type": ctype,
+        "original_url": orig,
+        "http_status": status or 200,
+        "method": "common_crawl",
+        "cc_record": {
+            "filename": fn,
+            "offset": off,
+            "length": ln,
+            "timestamp": rec.get("timestamp"),
+        },
+    }
+
+
+# --- archive.is ---
+
+def get_archive_is_content(url: str) -> dict:
+    for base in (ARCHIVE_IS_NEWEST, ARCHIVE_PH_NEWEST):
+        try:
+            r = session().get(base + url, timeout=(8, 15), allow_redirects=True)
+        except requests.RequestException as exc:
+            log.info("archive.is %s", exc)
+            continue
+        if r.status_code != 200 or not r.content:
+            continue
+        if "archive." not in (r.url or ""):
+            continue
+        text = r.text or ""
+        if is_challenge(text, r.status_code):
+            continue
+        return {
+            "status": "success",
+            "content": r.content,
+            "text": text,
+            "content_type": r.headers.get("content-type") or "text/html",
+            "archive_url": r.url,
+            "original_url": url,
+            "http_status": r.status_code,
+            "method": "archive_is",
+        }
+    return {"status": "error", "error": "no_archive_is_snapshot", "original_url": url}
+
+
+# --- Direct HTTP last ---
+
+def get_http(url: str) -> dict:
+    try:
+        r = session().get(url, timeout=(20, 60), allow_redirects=True)
+    except requests.RequestException as exc:
+        return {"status": "error", "error": str(exc), "original_url": url}
+    text = ""
+    ctype = r.headers.get("content-type") or ""
+    body = r.content or b""
+    if body and ("html" in ctype or "xml" in ctype or "text/" in ctype or not ctype):
+        text = body.decode(r.encoding or "utf-8", "replace")
+    if r.status_code != 200 or not body:
+        return {"status": "error", "error": f"http_{r.status_code}", "http_status": r.status_code}
+    if text and is_challenge(text, r.status_code):
+        return {"status": "error", "error": "challenge_or_shell", "http_status": r.status_code}
+    return {
+        "status": "success",
+        "content": body,
+        "text": text,
+        "content_type": ctype,
+        "original_url": url,
+        "http_status": r.status_code,
+        "method": "http",
+        "final_url": r.url,
+    }
+
+
+def fetch_with_fallbacks(
+    url: str,
+    *,
+    cc_record: Optional[dict] = None,
+    wayback_ts: Optional[str] = None,
+    try_archive_is: bool = False,
+    try_http: bool = True,
+    try_cc: bool = True,
+) -> dict:
+    """Prefer archives: CC WARC -> Wayback replay -> archive.is -> direct HTTP.
+
+    Brave Search skipped (no API key in this environment).
+    Playwright is attempted by the caller when this returns a SPA shell.
+    Does not run Wayback CDX search; Wayback is replay only.
+    """
+    errors = []
+    cc_recs: list[dict] = []
+    if cc_record and (cc_record.get("filename") or cc_record.get("warc_filename")):
+        cc_recs = [cc_record]
+    elif try_cc:
+        try:
+            cc_recs = search_common_crawl(url, limit=4)
+        except Exception as exc:
+            errors.append(f"common_crawl:{exc}")
+            cc_recs = []
+    for rec in cc_recs:
+        res = fetch_common_crawl_warc(rec)
+        if res.get("status") == "success" and (res.get("text") or res.get("content")):
+            return res
+        errors.append(f"common_crawl:{res.get('error')}")
+    if wayback_ts or url:
+        res = get_wayback_content(url, timestamp=wayback_ts)
+        if res.get("status") == "success" and (res.get("text") or res.get("content")):
+            return res
+        errors.append(f"wayback:{res.get('error')}")
+    if try_archive_is:
+        res = get_archive_is_content(url)
+        if res.get("status") == "success":
+            return res
+        errors.append(f"archive_is:{res.get('error')}")
+    if try_http:
+        res = get_http(url)
+        if res.get("status") == "success":
+            return res
+        errors.append(f"http:{res.get('error')}")
+    return {"status": "error", "error": "; ".join(errors) or "all_failed", "original_url": url}

scrapers/collect_ae.py

@@ -0,0 +1,413 @@
+#!/usr/bin/env python3
+"""UAE: Federal laws + Constitution from UAE Legislation.
+
+Official sources only:
+  https://uaelegislation.gov.ae  (General Secretariat of the UAE Cabinet)
+  List API: POST /en/legislations/list
+  Item:     /en/legislations/{id}
+  PDF:      /en/legislations/{id}/download
+  Constitution id=1000
+
+Federal laws (Federal Law / Federal Decree-Law) first. Cabinet resolutions
+and ministerial circulars are out of scope. No commercial compilations.
+No WAF bypass.
+
+On HTTP 429/403 of official URLs, archive_fallbacks.py of those URLs only.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import re
+import time
+import subprocess
+import sys
+import tempfile
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Optional
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import *
+import archive_fallbacks as af
+
+CC = "ae"
+COUNTRY = "United Arab Emirates"
+SOURCE_TYPE = "uaelegislation"
+LICENSE = (
+    "Official UAE Legislation texts (uaelegislation.gov.ae / UAE Cabinet). "
+    "Authentic Official Gazette prevails. Not legal advice."
+)
+UA = DEFAULT_UA + " source=https://uaelegislation.gov.ae/"
+PORTAL = "https://uaelegislation.gov.ae/"
+LIST = "https://uaelegislation.gov.ae/en/legislations/list"
+BROWSE = "https://uaelegislation.gov.ae/en/legislations"
+CONST_ID = "1000"
+WORKERS = 3
+SLEEP = 0.5
+log = logging.getLogger("ae")
+
+FED_RE = re.compile(
+    r"Federal(?:\s+Decree[-\s]?Law|\s+Law)\b|^Constitution\b|The Constitution of the United Arab Emirates",
+    re.I,
+)
+SKIP_RE = re.compile(r"Cabinet Resolution|Ministerial|Circular|Administrative Decision", re.I)
+ART_AE = re.compile(r"(?im)^\s*((?:Article|المادة)\s+[0-9\u0660-\u0669]+)\b")
+ID_RE = re.compile(r"/en/legislations/(\d+)(?:/|$|\?)")
+
+
+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 pdf_to_text(raw: bytes) -> str:
+    if not raw or raw[:4] != b"%PDF":
+        return ""
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=True) as tmp:
+            tmp.write(raw)
+            tmp.flush()
+            proc = subprocess.run(
+                ["pdftotext", "-layout", "-enc", "UTF-8", tmp.name, "-"],
+                check=False, capture_output=True, timeout=180,
+            )
+        if proc.returncode == 0 and proc.stdout:
+            return proc.stdout.decode("utf-8", "replace").strip()
+    except Exception as exc:
+        log.warning("pdftotext: %s", exc)
+    return ""
+
+
+def official_get(url: str, *, binary: bool = False, retries: int = 4) -> dict:
+    headers = {"Accept": "application/pdf, */*" if binary else "text/html, application/json, */*"}
+    try:
+        r = http_get(url, ua=UA, sleep=SLEEP, retries=retries, timeout=(20, 90), headers=headers)
+    except Exception as exc:
+        log.info("live fail %s: %s", url, exc)
+        r = None
+    if r is not None and r.status_code == 200 and r.content:
+        if binary or not af.is_challenge(r.text or "", r.status_code):
+            return {"ok": True, "content": r.content, "text": "" if binary else (r.text or ""),
+                    "method": "live", "status": 200}
+    if r is not None and r.status_code in (404, 410):
+        return {"ok": False, "error": f"http_{r.status_code}", "status": r.status_code}
+    need = r is None or r.status_code in (429, 403, 503, 502, 504)
+    if r is not None and not binary and af.is_challenge(r.text or "", r.status_code):
+        need = True
+    if need:
+        res = af.fetch_with_fallbacks(url, try_http=False, try_cc=True, try_archive_is=False)
+        if res.get("status") == "success" and (res.get("content") or res.get("text")):
+            return {"ok": True, "content": res.get("content") or b"", "text": res.get("text") or "",
+                    "method": res.get("method") or "archive", "archive": res}
+        return {"ok": False, "error": (res or {}).get("error") or "archive_fail"}
+    return {"ok": False, "error": f"http_{getattr(r, 'status_code', 0)}"}
+
+
+def session_token() -> tuple[object, str]:
+    sess = get_session(UA, pool=WORKERS)
+    r = sess.get(BROWSE, timeout=(20, 60), headers={"User-Agent": UA, "Accept": "text/html"})
+    m = re.search(r'_token:\s*"([^"]+)"', r.text or "")
+    token = m.group(1) if m else ""
+    # also csrf cookie
+    if not token:
+        m = re.search(r'name="csrf-token"\s+content="([^"]+)"', r.text or "")
+        token = m.group(1) if m else ""
+    return sess, token
+
+
+def list_page(sess, token: str, page: int, law_types: list) -> dict:
+    payload = {
+        "_token": token,
+        "page": page,
+        "paginateBy": 50,
+        "year": None,
+        "lawTypes": law_types,
+        "subject": "",
+    }
+    headers = {
+        "User-Agent": UA,
+        "Accept": "application/json, text/javascript, */*; q=0.01",
+        "Content-Type": "application/json",
+        "X-Requested-With": "XMLHttpRequest",
+        "Referer": BROWSE,
+    }
+    time.sleep(SLEEP)
+    r = sess.post(LIST, json=payload, headers=headers, timeout=(20, 90))
+    if r.status_code in (429, 403, 503):
+        log.info("list HTTP %s page=%s — archive not used for POST body", r.status_code, page)
+        return {}
+    if r.status_code != 200:
+        log.info("list HTTP %s page=%s", r.status_code, page)
+        return {}
+    try:
+        return r.json()
+    except Exception:
+        return {}
+
+
+def parse_list_payload(js: dict) -> list[dict]:
+    items = []
+    blob = json.dumps(js, ensure_ascii=False)
+    html = js.get("html") or js.get("view") or js.get("content") or ""
+    # data array
+    data = js.get("data") or js.get("legislations") or js.get("items") or []
+    if isinstance(data, dict):
+        data = data.get("data") or data.get("items") or []
+    if isinstance(data, list):
+        for rec in data:
+            if not isinstance(rec, dict):
+                continue
+            lid = rec.get("id") or rec.get("legislation_id") or rec.get("legislationId")
+            title = rec.get("title") or rec.get("name") or rec.get("title_en") or ""
+            if lid:
+                items.append({
+                    "id": str(lid),
+                    "title": re.sub(r"\s+", " ", str(title)).strip(),
+                    "year": rec.get("year") or rec.get("issue_year"),
+                    "law_type": rec.get("law_type") or rec.get("type"),
+                    "source": "list_json",
+                })
+    for lid in ID_RE.findall(html + "\n" + blob):
+        items.append({"id": lid, "title": "", "source": "list_html"})
+    # titles next to ids in HTML
+    for lid, title in re.findall(
+        r'href="[^"]*/en/legislations/(\d+)[^"]*"[^>]*>\s*([^<]{3,220})\s*<', html
+    ):
+        items.append({"id": lid, "title": re.sub(r"\s+", " ", title).strip(), "source": "list_anchor"})
+    return items
+
+
+def load_catalog() -> list[dict]:
+    p = ROOT / CC / "raw" / "catalog.jsonl"
+    if not p.exists() or p.stat().st_size < 50:
+        return []
+    items, seen = [], set()
+    with p.open(encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                row = json.loads(line)
+            except Exception:
+                continue
+            lid = str(row.get("id") or "")
+            if not lid or lid in seen:
+                continue
+            seen.add(lid)
+            items.append(row)
+    return items
+
+
+def add_item(items, seen, row):
+    lid = str(row.get("id") or "")
+    if not lid or lid in seen:
+        if lid in seen and row.get("title"):
+            for it in items:
+                if str(it.get("id")) == lid and not it.get("title"):
+                    it["title"] = row["title"]
+        return
+    seen.add(lid)
+    row["url"] = f"https://uaelegislation.gov.ae/en/legislations/{lid}"
+    row["pdf_url"] = f"https://uaelegislation.gov.ae/en/legislations/{lid}/download"
+    items.append(row)
+    append_catalog(CC, row)
+
+
+def is_federal(title: str, lid: str) -> bool:
+    if lid == CONST_ID:
+        return True
+    t = title or ""
+    if SKIP_RE.search(t):
+        return False
+    if not t:
+        return True
+    if FED_RE.search(t) or "قانون اتحادي" in t or "مرسوم بقانون" in t:
+        return True
+    # type-2/3/14 catalog ids are federal even when title is Arabic-only
+    return True
+
+
+def discover() -> list[dict]:
+    items = load_catalog()
+    seen = {str(x.get("id")) for x in items}
+    add_item(items, seen, {
+        "id": CONST_ID,
+        "title": "The Constitution of the United Arab Emirates",
+        "kind": "constitution",
+        "source": "known",
+    })
+    if len(items) >= 80:
+        log.info("resume catalog %s", len(items))
+        return items
+    sess, token = session_token()
+    if not token:
+        log.warning("no csrf token; list API may fail")
+    # 14 Constitution, 2 Federal Law, 3 Federal Decree-Law. Type 1 is Cabinet Resolutions.
+    for types in ([14], [2], [3]):
+        js0 = list_page(sess, token, 1, types)
+        total = int(js0.get("total") or 0)
+        pages = int(js0.get("pages") or 1)
+        log.info("list types=%s total=%s pages=%s", types, total, pages)
+        for rec in parse_list_payload(js0):
+            add_item(items, seen, rec)
+        for p in range(2, min(pages, 40) + 1):
+            js = list_page(sess, token, p, types)
+            if not js:
+                break
+            before = len(items)
+            for rec in parse_list_payload(js):
+                add_item(items, seen, rec)
+            log.info("page %s types=%s new_total=%s", p, types, len(items))
+            if len(items) == before and p > 2:
+                break
+        # collect all three federal families
+    log.info("discovered %s", len(items))
+    return items
+
+
+def page_title(html: str, fallback: str) -> str:
+    m = re.search(r"<title>\s*([^<]+)", html or "", re.I)
+    if m:
+        t = re.sub(r"\s+", " ", m.group(1)).strip()
+        t = re.sub(r"^United Arab Emirates Legislations\s*[|:—-]+\s*", "", t, flags=re.I)
+        if t:
+            return t
+    m = re.search(r"<h1[^>]*>([\s\S]{3,240})</h1>", html or "", re.I)
+    if m:
+        t = re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", m.group(1))).strip()
+        if t:
+            return t
+    return fallback
+
+
+def fetch_one(it: dict, done: set[str]) -> str:
+    lid = str(it.get("id") or "")
+    if not lid:
+        return "fail"
+    rid = slug_id(CC, f"leg-{lid}")
+    if rid in done:
+        return "skip"
+    url = it.get("url") or f"https://uaelegislation.gov.ae/en/legislations/{lid}"
+    pdf_url = it.get("pdf_url") or f"{url}/download"
+    page = official_get(url)
+    html = page.get("text") or ""
+    title = page_title(html, it.get("title") or f"Legislation {lid}")
+    if not is_federal(title, lid):
+        return "skip"
+    text = ""
+    backend = page.get("method") or "live"
+    pdf = official_get(pdf_url, binary=True)
+    if pdf.get("ok"):
+        text = pdf_to_text(pdf.get("content") or b"")
+        backend = f"pdf-{(pdf.get('method') or 'live')}"
+    if len(text) < 80 and html:
+        body = html_to_text(html)
+        m = re.search(r"(Article\s+1\b|المادة|We, |WE, |The President)", body)
+        if m:
+            body = body[m.start():]
+        if len(body) > len(text):
+            text = body
+            backend = f"html-{(page.get('method') or 'live')}"
+    if len(text) < 80:
+        log_failure(CC, {"identifier": lid, "source_url": url, "status": "failed",
+                         "reason": "empty_text", "title": title})
+        return "fail"
+    docs = split_articles(text, rid, url, None)
+    if not docs:
+        matches = list(ART_AE.finditer(text))
+        if len(matches) >= 2:
+            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("-")
+                docs.append({
+                    "id": f"{rid}-{aid}"[:180], "title": chunk.split("\n", 1)[0][:200],
+                    "text": chunk, "document_number": num, "source_url": url,
+                    "record_type": "article", "article_number": num, "law_identifier": rid,
+                    "metadata": {"text_extraction": {"source": "official", "backend": "collector"}},
+                })
+    kind = "constitution" if lid == CONST_ID or re.search(r"Constitution of the United Arab Emirates", title, re.I) else "statute"
+    rec = base_record(
+        cc=CC, country=COUNTRY, language="en", ident=f"leg-{lid}", title=title,
+        text=text, source_url=url, source_type=SOURCE_TYPE, license_text=LICENSE,
+        collector="ae-uaelegislation", date=iso_date(str(it.get("year"))) if it.get("year") else None,
+        official_identifier=lid, document_type=kind,
+        law_status="current", is_current=True, documents=docs,
+        extra_meta={
+            "discovery": {"method": "uaelegislation_list", "id": lid, "pdf_url": pdf_url,
+                          "retrieval": page.get("method")},
+            "text_extraction": {"source": "official", "backend": backend},
+        },
+    )
+    rec["languages"] = ["en"]
+    write_instrument(CC, rec)
+    return "ok"
+
+
+def main():
+    setup()
+    t0 = utcnow()
+    items = discover()
+    items = sorted(items, key=lambda x: (0 if str(x.get("id")) == CONST_ID else 1, int(x.get("id") or 0)))
+    done = existing_ids(CC)
+    ok = skip = fail = 0
+    log.info("queue %s already=%s", len(items), len(done))
+    with ThreadPoolExecutor(max_workers=WORKERS) as ex:
+        futs = [ex.submit(fetch_one, it, done) for it in items]
+        n = 0
+        for fut in as_completed(futs):
+            n += 1
+            try:
+                st = fut.result()
+            except Exception as exc:
+                st = "fail"
+                log_failure(CC, {"status": "failed", "reason": repr(exc)})
+            ok += st == "ok"
+            skip += st == "skip"
+            fail += st == "fail"
+            if n % 20 == 0 or n == len(items):
+                log.info("progress %s/%s ok=%s skip=%s fail=%s", n, len(items), ok, skip, fail)
+                write_summary(
+                    CC, country=COUNTRY,
+                    source="UAE Legislation (General Secretariat of the UAE Cabinet)",
+                    source_urls=[PORTAL, BROWSE], license_text=LICENSE,
+                    discovered=len(items), fetched=ok, skipped=skip, failed=fail,
+                    coverage="catalog-backed incomplete",
+                    notes="Federal laws + Constitution. Not commercial compilations.",
+                    last_run=utcnow(),
+                )
+    coverage = "snapshot" if ok else "empty"
+    if items and fail == 0 and ok + skip >= len(items):
+        coverage = "federal-laws snapshot"
+    notes = (
+        "Federal Law / Federal Decree-Law / Constitution from official "
+        "uaelegislation.gov.ae list API and PDF downloads. Cabinet resolutions "
+        "excluded. 429/403 uses archive_fallbacks of official URLs. Started "
+        f"{t0}."
+    )
+    write_summary(
+        CC, country=COUNTRY,
+        source="UAE Legislation (General Secretariat of the UAE Cabinet)",
+        source_urls=[PORTAL, BROWSE, f"https://uaelegislation.gov.ae/en/legislations/{CONST_ID}"],
+        license_text=LICENSE, discovered=len(items), fetched=ok, skipped=skip, failed=fail,
+        coverage=coverage, notes=notes, last_run=utcnow(), extra=f"started {t0}",
+    )
+    (ROOT / CC / "logs" / "DONE").write_text(json.dumps({
+        "ok": ok, "skip": skip, "fail": fail, "discovered": len(items), "coverage": coverage,
+    }, indent=2) + "\n", encoding="utf-8")
+    log.info("done ok=%s skip=%s fail=%s coverage=%s", ok, skip, fail, coverage)
+
+
+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