Refresh/add Samoa official snapshot (95 laws)

MANIFEST.md

@@ -0,0 +1,26 @@
+# ipfs_samoa_laws manifest
+
+generated_utc: 2026-09-08T22:53:33Z
+cc: ws
+laws_rows: 95
+articles_rows: 2274
+laws_bytes: 1516770
+articles_bytes: 1509227
+laws_sha256: cf6d5b17292791c98d52735f59c67dc9f1332a13a8eaa37fa1f1a66bf2326a90
+articles_sha256: cf0c5a98ba71d0b4c75a7c86b560c9f900e7a0ab7927258e7f3db021352f4d3f
+laws_parquet: /workspace/legal-corpora/hf-staging/ipfs_samoa_laws/data/laws.parquet
+articles_parquet: /workspace/legal-corpora/hf-staging/ipfs_samoa_laws/data/articles.parquet
+compression: zstd
+collector: scrapers/collect_ws.py
+license: Official Samoan consolidation texts; AG / authentic text prevails; not legal advice
+retrieval: live-official
+live_instruments: 95
+archive_instruments: 0
+wayback_instruments: 0
+common_crawl_instruments: 0
+archive_is_instruments: 0
+constitution_present: true
+catalog_expected: 267
+catalog_gap: 172
+gaps: Consolidation of Laws of Samoa PDFs from official ag.gov.ws. Parliament SharePoint skipped (403). Not legal advice.
+uploaded: false

README.md

@@ -0,0 +1,63 @@
+---
+pretty_name: Samoa Consolidation of Laws (Attorney General)
+license: other
+license_name: ws-ag-official-texts
+language:
+- en
+task_categories:
+- text-retrieval
+tags:
+- legal
+- law
+- samoa
+- attorney-general
+- 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
+---
+
+# Samoa Consolidation of Laws (Attorney General)
+
+Research snapshot of official national legislation from **Attorney General Consolidation of Laws of Samoa (ag.gov.ws)**.
+
+**Not legal advice.** The official gazette / authentic source prevails over this corpus.
+
+## Snapshot
+
+| Field | Value |
+| --- | --- |
+| Snapshot date | 2026-09-08 |
+| Coverage | ag-consolidation-2023-pdfs |
+| Source | Attorney General Consolidation of Laws of Samoa (ag.gov.ws) |
+| Collector | `scrapers/collect_ws.py` |
+| Laws / instruments | 95 |
+| Articles | 2,274 |
+| Language | en |
+| Jurisdiction | Samoa |
+| License | `ws-ag-official-texts` |
+
+## Contents
+
+- `data/laws.parquet` — one row per instrument.
+- `data/articles.parquet` — article/section rows for the same snapshot.
+- `scrapers/collect_ws.py` — research collector used to build this snapshot.
+
+## License / reuse
+
+Official Samoan consolidation texts; AG / authentic text prevails; not legal advice.
+
+This dataset is **not legal advice**. The official source prevails.
+
+## Source
+
+- https://www.ag.gov.ws/consolidation-of-laws-of-samoa/
+
+## Known gaps
+
+Consolidation of Laws of Samoa PDFs from official ag.gov.ws. Parliament SharePoint skipped (403). Not legal advice.

data/articles.parquet

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

data/laws.parquet

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

scrapers/archive_fallbacks.py

@@ -0,0 +1,648 @@
+#!/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"
+WAYBACK_CDX_HTTP = "http://web.archive.org/cdx/search/cdx"
+WAYBACK_WEB_HTTP = "http://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:
+            try:
+                r = session().get(WAYBACK_CDX, params=items, timeout=(20, 90))
+            except requests.RequestException:
+                r = session().get(WAYBACK_CDX_HTTP, 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.
+
+    Prefer HTTP Wayback; HTTPS Wayback SSL-EOFs from this host (same as VN VBPL).
+    """
+    if timestamp:
+        path = f"/{timestamp}id_/{url}"
+    else:
+        path = f"/2id_/{url}"
+    r = None
+    last_err = None
+    candidates = [WAYBACK_WEB_HTTP + path, WAYBACK_WEB + path]
+    for attempt in range(1, 4):
+        target = candidates[min(attempt-1, len(candidates)-1)]
+        _sleep_wayback(0.8 if attempt == 1 else min(8.0, 1.8 * attempt))
+        try:
+            r = session().get(target, 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 < 3:
+            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 _http_cc_index(url: str) -> str:
+    if url.startswith("https://index.commoncrawl.org"):
+        return "http://" + url[len("https://"):]
+    return url
+
+
+def cc_indexes(n: int = 6) -> list[str]:
+    global _cc_indexes
+    if _cc_indexes is None:
+        cols = []
+        last_exc = None
+        for coll in (CC_COLLINFO, CC_COLLINFO.replace("https://", "http://", 1)):
+            try:
+                r = session().get(coll, timeout=30)
+                if r.status_code == 200:
+                    cols = r.json() or []
+                    break
+            except Exception as exc:
+                last_exc = exc
+                log.warning("cc collinfo %s: %s", coll, exc)
+        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(_http_cc_index(cdx or f"http://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 [
+            "http://index.commoncrawl.org/CC-MAIN-2026-34-index",
+            "http://index.commoncrawl.org/CC-MAIN-2024-33-index",
+        ]
+        if last_exc and not ids:
+            log.warning("cc collinfo fallback indexes after %s", last_exc)
+    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:
+            alt = _http_cc_index(idx) if idx.startswith("https://") else idx.replace("http://", "https://", 1)
+            try:
+                r = session().get(alt, params=params, timeout=(12, 25))
+            except requests.RequestException as exc2:
+                log.info("cc cdx %s fail %s / %s", idx, exc, exc2)
+                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_ws.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""Samoa: Consolidation of Laws PDFs from Attorney General (ag.gov.ws).
+
+Official only:
+  https://www.ag.gov.ws/consolidation-of-laws-of-samoa/
+
+≥267 public consolidation PDFs under /wp-content/uploads/.
+SKIP palemene.sharepoint.com (403 auth wall). No WAF bypass. Not legal advice.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import sys
+import time
+from pathlib import Path
+from typing import Optional
+from urllib.parse import unquote, urljoin
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import *
+import archive_fallbacks as af
+from pdf_extract_lib import extract_pdf_text, honest_split, split_by_pattern
+
+CC = "ws"
+COUNTRY = "Samoa"
+SOURCE_TYPE = "ag_gov_ws_consolidation"
+LICENSE = (
+    "Official Consolidation of Laws of Samoa as published by the Office of the "
+    "Attorney General (ag.gov.ws). The authentic official text prevails. Not legal advice."
+)
+UA = DEFAULT_UA + " source=https://www.ag.gov.ws/"
+INDEX = "https://www.ag.gov.ws/consolidation-of-laws-of-samoa/"
+SLEEP = float(os.environ.get("SLEEP", "0.55"))
+MIN_TEXT = 80
+log = logging.getLogger("ws")
+ART_WS = re.compile(
+    r"(?im)^\s*((?:Section|Article|PART|Part|SCHEDULE|Schedule)\s+[\dIVXLCDM]+[A-Za-z]?)\b"
+)
+PDF_HREF = re.compile(r'href=["\']([^"\']+\.pdf)["\']', re.I)
+
+
+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 catalog_path() -> Path:
+    return ROOT / CC / "raw" / "catalog.jsonl"
+
+
+def load_catalog() -> list[dict]:
+    p = catalog_path()
+    if not p.exists() or p.stat().st_size < 40:
+        return []
+    out = []
+    with p.open(encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                out.append(json.loads(line))
+            except Exception:
+                continue
+    return out
+
+
+def save_catalog(items: list[dict]) -> None:
+    atomic_write(catalog_path(), "".join(json.dumps(it, ensure_ascii=False) + "\n" for it in items))
+
+
+def title_from_url(url: str) -> str:
+    stem = Path(unquote(url.split("?")[0])).stem
+    stem = stem.replace("_", " ").replace("-", " ")
+    return re.sub(r"\s+", " ", stem).strip()[:240] or "Act"
+
+
+def get_bytes(url: str) -> tuple[bytes, str]:
+    if "sharepoint.com" in url.lower():
+        return b"", "skip_sharepoint"
+    try:
+        r = http_get(
+            url, ua=UA, sleep=SLEEP, timeout=(20, 180), retries=3,
+            headers={"Accept": "application/pdf,*/*", "Referer": INDEX},
+        )
+    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 and r.content[:4] == b"%PDF":
+        return r.content, "live"
+    res = af.fetch_with_fallbacks(url, try_http=False)
+    body = res.get("content") or b""
+    if res.get("status") == "success" and body[:4] == b"%PDF":
+        return body, res.get("method") or "archive"
+    return b"", "failed"
+
+
+def discover() -> list[dict]:
+    existing = load_catalog()
+    if existing and len(existing) >= 100:
+        log.info("resume catalog n=%s", len(existing))
+        return existing
+    try:
+        r = http_get(INDEX, ua=UA, sleep=SLEEP, timeout=(20, 90), retries=4)
+    except Exception as exc:
+        log.error("index fail: %s", exc)
+        return existing
+    if r.status_code != 200 or not r.text:
+        log.error("index HTTP %s", r.status_code)
+        return existing
+    items, seen = [], set()
+    for href in PDF_HREF.findall(r.text):
+        url = urljoin(INDEX, href.split("#")[0])
+        low = url.lower()
+        if "sharepoint.com" in low:
+            continue
+        if "ag.gov.ws" not in low:
+            continue
+        if url in seen:
+            continue
+        seen.add(url)
+        title = title_from_url(url)
+        ident = Path(unquote(url.split("?")[0])).stem[:160]
+        items.append({"url": url, "title": title, "identifier": ident, "kind": "act"})
+    save_catalog(items)
+    log.info("catalog n=%s", len(items))
+    return items
+
+
+def split_ws(text: str, law_id: str, source_url: str) -> list[dict]:
+    docs, _ = honest_split(CC, text, law_id, source_url)
+    if docs:
+        return docs
+    docs = split_articles(text, law_id, source_url)
+    if len(docs) >= 2:
+        return docs
+    return split_by_pattern(text, law_id, source_url, ART_WS, "section")
+
+
+def fetch_one(it: dict, done: set[str]) -> str:
+    url = it["url"]
+    ident = it.get("identifier") or Path(unquote(url.split("?")[0])).stem
+    rid = slug_id(CC, ident)
+    if rid in done:
+        return "skip"
+    body, method = get_bytes(url)
+    if method == "skip_sharepoint":
+        return "skip"
+    if body[:4] != b"%PDF":
+        log_failure(CC, {"id": rid, "url": url, "reason": f"not_pdf method={method}"})
+        return "fail"
+    text, backend, pages = extract_pdf_text(body, enable_ocr=True, ocr_lang="eng", ocr_max_pages=50)
+    if len(text) < MIN_TEXT:
+        log_failure(CC, {"id": rid, "url": url, "reason": f"empty_text backend={backend}"})
+        return "fail"
+    title = it.get("title") or title_from_url(url)
+    year_m = re.search(r"(19|20)\d{2}", title) or re.search(r"(19|20)\d{2}", url)
+    date = f"{year_m.group(0)}-01-01" if year_m else None
+    docs = split_ws(text, rid, url)
+    rec = base_record(
+        cc=CC, country=COUNTRY, language="en", ident=ident, title=title,
+        text=text, source_url=url, source_type=SOURCE_TYPE, license_text=LICENSE,
+        collector="collect_ws.py", date=date, official_identifier=ident,
+        document_type="statute", law_status="current", is_current=True,
+        documents=docs,
+        extra_meta={
+            "retrieval": method, "pdf_pages": pages,
+            "text_extraction": {"source": "official", "backend": backend},
+            "consolidation": "Laws of Samoa 2023 (AG)",
+        },
+    )
+    write_instrument(CC, rec)
+    done.add(rid)
+    log.info("ok %s method=%s chars=%s arts=%s", rid[:70], method, len(text), len(docs))
+    return "ok"
+
+
+def main():
+    setup()
+    t0 = utcnow()
+    max_new = int(os.environ.get("MAX_NEW", "0") or "0")
+    max_seconds = int(os.environ.get("MAX_SECONDS", "7200") or "7200")
+    t_start = time.time()
+    items = discover()
+    done = existing_ids(CC)
+    ok = skip = fail = 0
+    for it in items:
+        if max_new and ok >= max_new:
+            break
+        if time.time() - t_start > max_seconds:
+            break
+        status = fetch_one(it, done)
+        if status == "ok":
+            ok += 1
+        elif status == "skip":
+            skip += 1
+        else:
+            fail += 1
+    write_summary(
+        CC, country=COUNTRY, source="AG Consolidation of Laws of Samoa (ag.gov.ws)",
+        source_urls=[INDEX],
+        license_text=LICENSE, discovered=len(items), fetched=ok, skipped=skip, failed=fail,
+        coverage="ag-consolidation-2023-pdfs",
+        notes=(
+            "Consolidation of Laws of Samoa PDFs from official ag.gov.ws. "
+            "Parliament SharePoint binaries skipped (403). Not legal advice."
+        ),
+        last_run=t0,
+    )
+    log.info("done ok=%s skip=%s fail=%s catalog=%s", ok, skip, fail, len(items))
+
+
+if __name__ == "__main__":
+    main()

scrapers/common.py

@@ -0,0 +1,531 @@
+#!/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
+
+
+def pdf_bytes_to_text(raw: bytes, timeout: int = 180) -> str:
+    """Extract text from PDF bytes via pdftotext. Empty on failure."""
+    import subprocess
+    if not raw:
+        return ""
+    if raw[:4] != b"%PDF":
+        idx = raw.find(b"%PDF", 0, 8192)
+        if idx < 0:
+            return ""
+        raw = raw[idx:]
+    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=timeout,
+            )
+        if proc.returncode == 0 and proc.stdout:
+            return proc.stdout.decode("utf-8", "replace").strip()
+    except Exception:
+        return ""
+    return ""

scrapers/pdf_extract_lib.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+"""PDF text extraction helpers mirroring ipfs_datasets_py IntegratedPDFProcessor.
+
+Prefer pdfplumber -> pymupdf -> pdftotext; OCR (tesseract) only when text layer
+is missing or garbage. Honest article splits require >=2 heading matches.
+"""
+from __future__ import annotations
+
+import io
+import logging
+import re
+import subprocess
+import tempfile
+from typing import Optional
+
+log = logging.getLogger("pdf_extract_lib")
+
+# Spaced-out OCR garbage like "D  IA     R       IO"
+_GARBAGE_SPACING = re.compile(r"(?:^[A-Za-z]\s+){6,}", re.M)
+
+
+def is_garbage_text(text: str) -> bool:
+    if not text or len(text) < 40:
+        return True
+    if text.lstrip().startswith("%PDF") or "endobj" in text[:200]:
+        return True
+    if "IHDR" in text[:120] or text[:8].startswith("\x89PNG") or "PNG" in text[:20] and "IHDR" in text[:80]:
+        return True
+    sample = text[:8000]
+    # Broken ToUnicode / CID font dumps from Arabic/Persian PDFs
+    if sample.count("(cid:") >= 8:
+        return True
+    arabic = sum(1 for ch in sample if "\u0600" <= ch <= "\u06FF")
+    ctrl = sum(1 for ch in sample if ord(ch) < 32 and ch not in "\n\r\t\x0c")
+    n = max(1, len(sample))
+    # Encoding-corrupt Arabic/Persian PDFs: many controls / almost no Arabic script
+    if len(sample) > 500 and (ctrl / n) > 0.04 and (arabic / n) < 0.05:
+        return True
+    if len(sample) > 800 and arabic < 80 and sample.count("@") > 30:
+        return True
+    letters = sum(ch.isalpha() for ch in sample)
+    spaces = sample.count(" ")
+    if letters < 80 and arabic < 40:
+        return True
+    # Mojibake Latin stand-in for Arabic (common in old MoJ PDFs)
+    ascii_letters = sum(ch.isalpha() and ord(ch) < 128 for ch in sample)
+    if len(sample) > 500 and arabic < 20 and ascii_letters > 400:
+        return True
+    if spaces > letters * 1.8 and _GARBAGE_SPACING.search(sample):
+        return True
+    singles = len(re.findall(r"(?m)^\s*[A-Za-zÁÉÍÓÚÑáéíóúñ]\s*$", sample))
+    if singles > 30 and singles > letters * 0.15:
+        return True
+    return False
+
+
+def extract_pdfplumber(raw: bytes, max_pages: int = 200) -> tuple[str, int]:
+    import pdfplumber
+    with pdfplumber.open(io.BytesIO(raw)) as pdf:
+        n = len(pdf.pages)
+        parts = []
+        for page in pdf.pages[:max_pages]:
+            try:
+                parts.append(page.extract_text() or "")
+            except Exception:
+                continue
+    text = "\n".join(parts)
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text).strip()
+    return text, n
+
+
+def extract_pymupdf(raw: bytes, max_pages: int = 200) -> tuple[str, int]:
+    import pymupdf
+    doc = pymupdf.open(stream=raw, filetype="pdf")
+    n = doc.page_count
+    parts = [page.get_text() for page in doc[:max_pages]]
+    text = "\n".join(parts)
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text).strip()
+    return text, n
+
+
+def extract_pdftotext(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 extract_ocr(raw: bytes, lang: str = "eng", max_pages: int = 40, dpi: int = 120) -> tuple[str, int]:
+    """Render pages with pymupdf and OCR via tesseract CLI."""
+    import pymupdf
+    doc = pymupdf.open(stream=raw, filetype="pdf")
+    n = doc.page_count
+    parts = []
+    mat = pymupdf.Matrix(dpi / 72, dpi / 72)
+    for i, page in enumerate(doc):
+        if i >= max_pages:
+            break
+        pix = page.get_pixmap(matrix=mat, alpha=False)
+        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as img:
+            pix.save(img.name)
+            img_path = img.name
+        try:
+            env = dict(**__import__("os").environ)
+            env["OMP_THREAD_LIMIT"] = "1"
+            env["TESSDATA_PREFIX"] = env.get("TESSDATA_PREFIX", "/usr/share/tesseract-ocr/5/tessdata")
+            proc = subprocess.run(
+                ["tesseract", img_path, "stdout", "-l", lang, "--psm", "6"],
+                capture_output=True, text=True, timeout=180, env=env,
+            )
+            if proc.returncode == 0 and proc.stdout:
+                parts.append(proc.stdout)
+        except Exception as exc:
+            log.debug("ocr page %s: %s", i, exc)
+        finally:
+            try:
+                import os
+                os.unlink(img_path)
+            except Exception:
+                pass
+    text = "\n".join(parts)
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text).strip()
+    return text, n
+
+
+def extract_pdf_text(
+    raw: bytes,
+    *,
+    enable_ocr: bool = True,
+    ocr_lang: str = "eng",
+    ocr_max_pages: int = 40,
+) -> tuple[str, str, int]:
+    """Return (text, method, page_count). Mirrors IntegratedPDFProcessor order."""
+    if not raw:
+        return "", "not_pdf", 0
+    if raw[:4] != b"%PDF":
+        idx = raw.find(b"%PDF", 0, 65536)
+        if idx < 0:
+            return "", "not_pdf", 0
+        raw = raw[idx:]
+    best_text, best_method, pages = "", "failed", 0
+    for name, fn in (
+        ("pdfplumber", lambda: extract_pdfplumber(raw)),
+        ("pymupdf", lambda: extract_pymupdf(raw)),
+    ):
+        try:
+            text, pages = fn()
+            if text and not is_garbage_text(text) and len(text) >= 80:
+                return text, name, pages
+            if len(text) > len(best_text):
+                best_text, best_method = text, name
+        except Exception as exc:
+            log.debug("%s failed: %s", name, exc)
+    try:
+        text = extract_pdftotext(raw)
+        if text and not is_garbage_text(text) and len(text) >= 80:
+            return text, "pdftotext", pages
+        if len(text) > len(best_text):
+            best_text, best_method = text, "pdftotext"
+    except Exception:
+        pass
+    if enable_ocr and (is_garbage_text(best_text) or len(best_text) < 120):
+        try:
+            text, pages = extract_ocr(raw, lang=ocr_lang, max_pages=ocr_max_pages)
+            if text and len(text) >= 80 and not is_garbage_text(text):
+                return text, "ocr_tesseract", pages
+            if len(text) > len(best_text):
+                best_text, best_method = text, "ocr_tesseract"
+        except Exception as exc:
+            log.debug("ocr failed: %s", exc)
+    return best_text, best_method if best_text else "failed", pages
+
+
+def normalize_bidi(text: str) -> str:
+    return re.sub(r"[\u200e\u200f\u202a-\u202e\u2066-\u2069\u200c\u200d\ufeff]", "", text or "")
+
+
+_EASTERN_DIGITS = str.maketrans(
+    "\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669"
+    "\u06f0\u06f1\u06f2\u06f3\u06f4\u06f5\u06f6\u06f7\u06f8\u06f9",
+    "01234567890123456789",
+)
+
+
+def normalize_rtl_text(text: str) -> str:
+    """Strip bidi marks and map Arabic/Persian digits to ASCII for heading regexes."""
+    t = normalize_bidi(text or "")
+    t = re.sub(r"[\u00ad\u200b]", "", t)
+    return t.translate(_EASTERN_DIGITS)
+
+
+
+def split_by_pattern(
+    text: str,
+    law_id: str,
+    source_url: str,
+    pat: re.Pattern,
+    record_type: str = "article",
+    min_chunk: int = 40,
+    max_docs: int = 4000,
+) -> list[dict]:
+    matches = list(pat.finditer(text or ""))
+    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()
+        if len(chunk) < min_chunk:
+            continue
+        num = re.sub(r"\s+", " ", m.group(1)).strip()
+        aid = re.sub(r"[^\w\u0600-\u06FF\u1200-\u137F]+", "-", num.lower(), flags=re.U).strip("-")[:80]
+        heading = chunk.split("\n", 1)[0][:200]
+        docs.append({
+            "id": f"{law_id}-{aid}"[:180],
+            "title": heading,
+            "text": chunk,
+            "date_filed": None,
+            "document_number": num,
+            "source_url": source_url,
+            "record_type": record_type,
+            "article_number": num,
+            "law_identifier": law_id,
+            "metadata": {
+                "text_extraction": {
+                    "source": "official",
+                    "backend": "honest_heading_split",
+                    "parser": "ipfs_datasets_py.IntegratedPDFProcessor+heading_split",
+                    "pattern": pat.pattern[:100],
+                }
+            },
+        })
+        if len(docs) >= max_docs:
+            break
+    return docs if len(docs) >= 2 else []
+
+
+# Country-specific honest patterns (tried in order)
+COUNTRY_PATTERNS: dict[str, list[tuple[str, re.Pattern, str]]] = {
+    "sv": [
+        ("articulo", re.compile(r"(?im)^\s*((?:Art(?:[íi]culo|\.)?|ART[IÍ]CULO)\s+\d+[º°a-z.]*)"), "article"),
+    ],
+    "tn": [
+        ("fasl", re.compile(r"(?m)^\s*((?:الفصل|المادة)\s+\S+)"), "article"),
+        ("article", re.compile(r"(?im)^\s*((?:Article|Art\.)\s+\d+)"), "article"),
+    ],
+    "et": [
+        ("article_heading", re.compile(r"(?im)^\s*((?:Article|Art\.)\s+\d+\.?)\s*(?:[.\-–—:]|\s+[A-Z\"“])"), "article"),
+        ("article_loose", re.compile(r"(?im)^\s*((?:Article|Art\.)\s+\d+)"), "article"),
+        ("article_inline", re.compile(r"(?im)((?:Article|Art\.)\s+\d+)(?![\d])"), "article"),
+        ("anqets", re.compile(r"(?m)^\s*((?:አንቀጽ|አንቀፅ)\s*[/\.]?\s*\d+)"), "article"),
+        ("anqets_inline", re.compile(r"(?m)((?:አንቀጽ|አንቀፅ)\s*[/.]?\s*\d+)"), "article"),
+    ],
+    "jm": [
+        ("section", re.compile(r"(?im)^\s*((?:Section|SECTION)\s+\d+[A-Za-z]?\.?)"), "section"),
+        ("part", re.compile(r"(?im)^\s*((?:PART|Part)\s+[IVXLC\d]+)"), "section"),
+    ],
+    "fj": [
+        ("numbered_emdash", re.compile(r"(?m)^\s*((?:\d+)\.—)"), "article"),
+        ("section", re.compile(r"(?im)^\s*((?:Section|SECTION|Article|ARTICLE)\s+\d+)"), "article"),
+        ("chapter", re.compile(r"(?im)^\s*((?:CHAPTER|Chapter)\s+\d+)"), "section"),
+    ],
+    "la": [
+        ("article", re.compile(r"(?im)^\s*((?:Article|Art\.|ມາດຕາ)\s*\d+)"), "article"),
+    ],
+    "lk": [
+        ("section", re.compile(r"(?im)^\s*((?:Section|SECTION)\s+\d+[A-Za-z]?)"), "section"),
+        ("article", re.compile(r"(?im)^\s*((?:Article|ARTICLE)\s+\d+)"), "article"),
+    ],
+    "md": [
+        ("articolul", re.compile(r"(?im)^\s*((?:Articolul|Art\.)\s*\d+(?:\^[0-9]+)?)"), "article"),
+        ("articolul_inline", re.compile(r"(?im)((?:Articolul|Art\.)\s*\d+(?:\^[0-9]+)?)\s*[.\-–—:]"), "article"),
+    ],
+    "iq": [
+        ("mada", re.compile(r"(?m)^\s*((?:المادة|مادة)\s*[-–—:]*\s*\d+)(?!\d)"), "article"),
+        ("mada_ocr", re.compile(r"(?m)^\s*((?:المادة|مادة)\s*[-–—:\s]*\d+)(?!\d)"), "article"),
+        ("fasl", re.compile(r"(?m)^\s*((?:الفصل|الباب)\s+\S+)"), "section"),
+        ("article_en", re.compile(r"(?im)^\s*((?:Article|Art\.?)\s+\d+)(?!\d)"), "article"),
+    ],
+    "ir": [
+        ("mada", re.compile(r"(?m)^\s*((?:ماده)\s*(?:واحده|\d+))(?!\d)"), "article"),
+        ("mada_prefixed", re.compile(
+            r"(?m)^\s*(?:\d+[\-–—ـ.)\]]*\s*)?((?:ماده)\s*(?:واحده|\d+))(?!\d)"
+        ), "article"),
+        ("fasl_bab", re.compile(
+            r"(?m)^\s*((?:فصل|باب)\s*(?:اول|دوم|سوم|چهارم|پنجم|ششم|هفتم|هشتم|نهم|دهم|\d+))"
+        ), "section"),
+        ("article_en", re.compile(r"(?im)^\s*((?:Article|Art\.?)\s+\d+)(?!\d)"), "article"),
+    ],
+    "mz": [
+        ("artigo", re.compile(r"(?im)^\s*((?:Artigo|Art\.|ARTIGO)\s+\d+[ºªo°a-zA-Z]?)"), "article"),
+    ],
+}
+
+
+def honest_split(cc: str, text: str, law_id: str, source_url: str) -> tuple[list[dict], str]:
+    if cc in ("tn", "iq", "ir", "dz", "lb", "ma", "eg", "sa", "ae"):
+        text_n = normalize_rtl_text(text)
+    else:
+        text_n = text
+    for name, pat, rtype in COUNTRY_PATTERNS.get(cc, []):
+        docs = split_by_pattern(text_n, law_id, source_url, pat, rtype)
+        if docs:
+            return docs, name
+    # shared fallback
+    from common import split_articles
+    docs = split_articles(text_n, law_id, source_url)
+    if len(docs) >= 2:
+        return docs, "common_article_split"
+    return [], "none"

scrapers/world_lib.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python3
+"""Shared helpers for new-country official gazette collectors."""
+from __future__ import annotations
+
+import logging
+import os
+import re
+import time
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urljoin, urlparse
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from common import (
+    ROOT,
+    DEFAULT_UA,
+    base_record,
+    ensure_dirs,
+    existing_ids,
+    html_to_text,
+    http_get,
+    iso_date,
+    log_failure,
+    slug_id,
+    split_articles,
+    utcnow,
+    write_instrument,
+    write_summary,
+)
+import archive_fallbacks as af
+
+log = logging.getLogger("world_lib")
+
+MIN_TEXT = 80
+MAX_PDF = 35 * 1024 * 1024
+
+
+def setup_log(cc: str, name: str | None = None) -> None:
+    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),
+        ],
+        force=True,
+    )
+
+
+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 split_custom(text: str, law_id: str, source_url: str, date: Optional[str], pattern: Optional[re.Pattern]) -> list[dict]:
+    docs = split_articles(text, law_id, source_url, date)
+    if not pattern:
+        return docs
+    matches = list(pattern.finditer(text or ""))
+    if len(matches) < 2:
+        return docs if len(docs) >= 2 else []
+    out = []
+    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()
+        if len(chunk) < 20:
+            continue
+        num = re.sub(r"\s+", " ", m.group(1)).strip()
+        aid = re.sub(r"[^a-zA-Z0-9\u0400-\u04FF\u0530-\u058F-]+", "-", num.lower()).strip("-")[:80]
+        heading = chunk.split("\n", 1)[0][:200]
+        out.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(out) >= 4000:
+            break
+    return out if len(out) >= 2 else docs
+
+
+
+def normalize_official_url(url: str) -> str:
+    """Fix CDX quirks: https://host:80/... breaks TLS (WRONG_VERSION_NUMBER)."""
+    if not url:
+        return url
+    url = url.replace("http://", "https://", 1) if "lawcommission.gov.np" in url and url.startswith("http://") else url
+    url = url.replace("https://www.lawcommission.gov.np:80/", "https://www.lawcommission.gov.np/")
+    url = url.replace("https://lawcommission.gov.np:80/", "https://lawcommission.gov.np/")
+    url = url.replace(":80/", "/") if url.startswith("https://") and ":80/" in url else url
+    url = url.replace(":80?", "?") if url.startswith("https://") and ":80?" in url else url
+    return url
+
+def live_get(url: str, *, ua: str = DEFAULT_UA, timeout: tuple = (20, 90), verify: bool = True, retries: int = 3):
+    url = normalize_official_url(url)
+    import requests
+    from requests.packages.urllib3.exceptions import InsecureRequestWarning
+    requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+    last = None
+    headers = {"User-Agent": ua, "Accept": "application/pdf, text/html, application/xml, */*"}
+    for attempt in range(1, retries + 1):
+        try:
+            time.sleep(0.2)
+            resp = requests.get(url, timeout=timeout, headers=headers, verify=verify, allow_redirects=True)
+            return resp
+        except Exception as exc:
+            last = exc
+            if verify and ("SSL" in type(exc).__name__ or "SSL" in str(exc)):
+                try:
+                    resp = requests.get(url, timeout=timeout, headers=headers, verify=False, allow_redirects=True)
+                    return resp
+                except Exception as exc2:
+                    last = exc2
+            time.sleep(min(8, 1.5 * attempt))
+    raise RuntimeError(f"live_get failed {url}: {last}")
+
+
+def fetch_official(
+    url: str,
+    *,
+    ua: str = DEFAULT_UA,
+    verify: bool = True,
+    wayback: bool = True,
+    wayback_ts: Optional[str] = None,
+    min_text: int = MIN_TEXT,
+) -> dict:
+    """Live official URL first; Wayback of the same official URL on failure. No WAF bypass."""
+    url = normalize_official_url(url)
+    out = {
+        "status": "error",
+        "text": "",
+        "content": b"",
+        "source_url": url,
+        "method": "",
+        "content_type": "",
+        "error": "",
+    }
+    body = b""
+    ctype = ""
+    try:
+        r = live_get(url, ua=ua, verify=verify)
+        body = r.content or b""
+        ctype = r.headers.get("content-type") or ""
+        if r.status_code == 200 and body:
+            if body[:4] == b"%PDF" or "pdf" in ctype.lower():
+                text = pdf_to_text(body)
+                if len(text) >= min_text:
+                    out.update(status="success", text=text, content=body, method="http_pdf", content_type=ctype)
+                    return out
+            text = ""
+            if "html" in ctype.lower() or "xml" in ctype.lower() or "json" in ctype.lower() or body[:1] in (b"<", b"{", b"["):
+                raw = body.decode(r.encoding or "utf-8", "replace")
+                if af.is_challenge(raw, r.status_code):
+                    out["error"] = "challenge_or_shell"
+                else:
+                    text = html_to_text(raw) if "<" in raw[:500] else raw
+                    if len(text) >= min_text and not af.is_spa_shell(raw, text):
+                        out.update(status="success", text=text, content=body, method="http_html", content_type=ctype)
+                        return out
+                    if len(text) < min_text:
+                        out["error"] = "short_or_spa"
+            elif body[:4] == b"%PDF":
+                out["error"] = "pdf_extract_failed"
+            elif len(body) > min_text:
+                try:
+                    text = body.decode("utf-8", "replace")
+                    if text.lstrip().startswith("%PDF") or "endobj" in text[:200]:
+                        out["error"] = "raw_pdf_bytes"
+                    elif len(text) >= min_text:
+                        out.update(status="success", text=text, content=body, method="http_text", content_type=ctype)
+                        return out
+                except Exception:
+                    pass
+        else:
+            out["error"] = f"http_{getattr(r, 'status_code', '?')}"
+    except Exception as exc:
+        out["error"] = f"live:{exc}"
+
+    if wayback:
+        try:
+            w = af.get_wayback_content(url, timestamp=wayback_ts)
+            if w.get("status") == "success":
+                raw_b = w.get("content") or b""
+                raw_t = w.get("text") or ""
+                if (isinstance(raw_b, bytes) and raw_b[:4] == b"%PDF") or (raw_t[:4] == "%PDF"):
+                    pdf_bytes = raw_b if isinstance(raw_b, bytes) and raw_b[:4] == b"%PDF" else raw_t.encode("latin-1", "replace")
+                    text = pdf_to_text(pdf_bytes)
+                    if len(text) >= min_text and not text.lstrip().startswith("%PDF"):
+                        out.update(
+                            status="success",
+                            text=text,
+                            content=pdf_bytes,
+                            method="wayback_pdf",
+                            source_url=w.get("url") or url,
+                            content_type="application/pdf",
+                        )
+                        return out
+                    out["error"] = (out.get("error") or "") + ";pdf_extract_failed"
+                    return out
+                if not raw_t and isinstance(raw_b, bytes):
+                    raw_t = raw_b.decode("utf-8", "replace")
+                if raw_t.lstrip().startswith("%PDF") or "endobj" in raw_t[:200]:
+                    out["error"] = (out.get("error") or "") + ";raw_pdf_bytes"
+                    return out
+                text = html_to_text(raw_t) if "<" in (raw_t[:400] or "") else raw_t
+                if len(text) >= min_text and not af.is_challenge(raw_t, 200):
+                    out.update(
+                        status="success",
+                        text=text,
+                        content=raw_b if isinstance(raw_b, bytes) else raw_t.encode("utf-8", "replace"),
+                        method="wayback_html",
+                        source_url=w.get("url") or url,
+                        content_type=w.get("content_type") or "text/html",
+                    )
+                    return out
+                out["error"] = (out.get("error") or "") + ";wayback_short"
+            else:
+                out["error"] = (out.get("error") or "") + f";wayback:{w.get('error')}"
+        except Exception as exc:
+            out["error"] = (out.get("error") or "") + f";wayback:{exc}"
+    return out
+
+
+def first_title(text: str, fallback: str) -> str:
+    for line in (text or "").splitlines():
+        s = line.strip()
+        if len(s) >= 12 and not s.lower().startswith("just a moment"):
+            return s[:240]
+    return fallback[:240]
+
+
+def save_instrument(
+    *,
+    cc: str,
+    country: str,
+    language: str,
+    ident: str,
+    title: str,
+    text: str,
+    source_url: str,
+    source_type: str,
+    license_text: str,
+    collector: str,
+    date: Optional[str] = None,
+    article_re: Optional[re.Pattern] = None,
+    extra_meta: Optional[dict] = None,
+) -> bool:
+    if not text or len(text) < MIN_TEXT:
+        return False
+    rid = slug_id(cc, ident)
+    docs = split_custom(text, rid, source_url, date, article_re)
+    rec = base_record(
+        cc=cc,
+        country=country,
+        language=language,
+        ident=ident,
+        title=title or first_title(text, ident),
+        text=text,
+        source_url=source_url,
+        source_type=source_type,
+        license_text=license_text,
+        collector=collector,
+        date=iso_date(date) or date,
+        documents=docs,
+        extra_meta=extra_meta,
+    )
+    write_instrument(cc, rec)
+    return True
+
+
+def cdx_urls(host_or_url: str, *, limit: int = 200, match_type: str = "prefix", extra_filters=None) -> list[dict]:
+    try:
+        hits = af.search_wayback_machine(
+            host_or_url,
+            limit=limit,
+            match_type=match_type,
+            collapse="urlkey",
+            extra_filters=extra_filters,
+        )
+    except Exception as exc:
+        log.info("cdx err %s: %s", host_or_url, exc)
+        return []
+    return hits or []
+
+
+def env_int(name: str, default: int) -> int:
+    try:
+        return int(os.environ.get(name, str(default)) or default)
+    except Exception:
+        return default