Add Namibia official snapshot (80 laws / 491 articles; parliament.gov.na)

MANIFEST.md

@@ -1,9 +1,26 @@
-# MANIFEST
+# ipfs_namibia_laws manifest
 
-- generated_at: 2026-09-05T10:17:38Z
-- laws: 165
-- articles: 650
-- files:
-  - data/laws.parquet: 2987233 bytes
-  - data/articles.parquet: 1809346 bytes
-  - README.md: 1861 bytes
+generated_utc: 2026-09-09T07:49:21Z
+cc: na
+laws_rows: 80
+articles_rows: 491
+laws_bytes: 895564
+articles_bytes: 733354
+laws_sha256: dcd1094c496a92cb7ca5cfca5490294bbe9c7a9092c3420498f48db7e0a059a0
+articles_sha256: aa8c57ca99695413c69bd0036138938d0a96668a3eeac86061f4162f52f71089
+laws_parquet: /workspace/legal-corpora/hf-staging/ipfs_namibia_laws/data/laws.parquet
+articles_parquet: /workspace/legal-corpora/hf-staging/ipfs_namibia_laws/data/articles.parquet
+compression: zstd
+collector: scrapers/collect_na.py
+license: Republic of Namibia — parliament.gov.na / laws.parliament.na / parliament.na / gov.na / moj.gov.na / opm.gov.na. Authentic Government Gazette / Act text prevails. Not legal advice.
+retrieval: live-and-wayback-of-official
+live_instruments: 80
+archive_instruments: 0
+wayback_instruments: 0
+common_crawl_instruments: 0
+archive_is_instruments: 0
+constitution_present: false
+catalog_expected: None
+catalog_gap: 
+gaps: Official Namibia law PDFs from parliament.gov.na, laws.parliament.na, parliament.na, gov.na, moj.gov.na, opm.gov.na and related *.gov.na hosts. Live-first; Wayback/CDX of official URLs on fail. Not AfricanLII / NamibLII / lac.org.na. No WAF bypass. Not legal advice.
+uploaded: false

README.md

@@ -1,7 +1,7 @@
 ---
-pretty_name: Laws of Namibia
+pretty_name: Namibia Acts and Official Gazettes (Parliament / Gov.na / MoJ / OPM)
 license: other
-license_name: na-parliament-laws
+license_name: na-parliament-gov-moj-official-texts
 language:
 - en
 task_categories:
@@ -10,6 +10,12 @@ tags:
 - legal
 - law
 - namibia
+- parliament
+- gov-na
+- moj
+- opm
+- gazette
+- acts
 - official-texts
 size_categories:
 - n<1K
@@ -21,44 +27,42 @@ configs:
   data_files: data/articles.parquet
 ---
 
-# Laws of Namibia
+# Namibia Acts and Official Gazettes (Parliament / Gov.na / MoJ / OPM)
 
-Research snapshot of official legislation collected from **Parliament of Namibia / Laws of Namibia (parliament.na, laws.parliament.na)**.
+Research snapshot of official national legislation from **Parliament (parliament.gov.na / laws.parliament.na / parliament.na) / Government Portal (gov.na) / Ministry of Justice (moj.gov.na) / Office of the Prime Minister (opm.gov.na) and other *.gov.na gazette hosts**.
 
-**Not legal advice.** Official gazettes / government portals prevail over this corpus.
+**Not legal advice.** The official gazette / authentic source prevails over this corpus.
 
 ## Snapshot
 
 | Field | Value |
 | --- | --- |
-| Snapshot date | 2026-09-05 |
-| Coverage | catalog-backed incomplete |
-| Source | Parliament of Namibia / Laws of Namibia (parliament.na, laws.parliament.na) |
+| Snapshot date | 2026-09-09 |
+| Coverage | catalog-backed incomplete (parliament/gov/moj/opm live + CDX Acts/gazettes PDFs) |
+| Source | Parliament (parliament.gov.na / laws.parliament.na / parliament.na) / Government Portal (gov.na) / Ministry of Justice (moj.gov.na) / Office of the Prime Minister (opm.gov.na) and other *.gov.na gazette hosts |
 | Collector | `scrapers/collect_na.py` |
-| Laws / instruments | 165 |
-| Articles | 650 |
+| Laws / instruments | 80 |
+| Articles | 491 |
 | Language | en |
 | Jurisdiction | Namibia |
-| License | `na-parliament-laws` |
+| License | `na-parliament-gov-moj-official-texts` |
 
 ## Contents
 
-- `data/laws.parquet` — one row per instrument (id, title, full text, dates, status, identifiers, article count, source URL).
-- `data/articles.parquet` — one row per article/section (`law_id`, article number, title, text, source URL).
+- `data/laws.parquet` — one row per instrument.
+- `data/articles.parquet` — article/section rows for the same snapshot.
 - `scrapers/collect_na.py` — research collector used to build this snapshot.
-- `scrapers/common.py` — shared collector helpers.
-- `scrapers/world_lib.py` — shared fetch (live official URL, Wayback fallback).
-- `scrapers/archive_fallbacks.py` — Wayback / Common Crawl CDX helpers.
 
 ## License / reuse
 
-Official government / gazette texts; reuse per public-sector terms of the
-source portal. This packaging, metadata, and collector script are provided
-for research.
+Republic of Namibia — parliament.gov.na / laws.parliament.na / parliament.na / gov.na / moj.gov.na / opm.gov.na. Authentic Government Gazette / Act text prevails. Not legal advice..
 
-This dataset is **not** an official consolidation and is **not legal advice**.
-The official source prevails.
+This dataset is **not legal advice**. The official source prevails.
 
-## Notes
+## Source
 
-Refreshed freeze after CC deepen. instruments=165.
+- https://www.parliament.gov.na/
+
+## Known gaps
+
+Official Namibia law PDFs from parliament.gov.na, laws.parliament.na, parliament.na, gov.na, moj.gov.na, opm.gov.na and related *.gov.na hosts. Live-first; Wayback/CDX of official URLs on fail. Not AfricanLII / NamibLII / lac.org.na. No WAF bypass. Not legal advice.

data/articles.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:56e2f6b042b5b8c46a89cb08bdd04c7aadbbb4a440fabdfc1960150fd55de2fc
-size 1809346
+oid sha256:aa8c57ca99695413c69bd0036138938d0a96668a3eeac86061f4162f52f71089
+size 733354

data/laws.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0371cb4c8096307944c343acbcdd099dde0ac7e69d22ccaaed4b38a83385ef41
-size 2987233
+oid sha256:dcd1094c496a92cb7ca5cfca5490294bbe9c7a9092c3420498f48db7e0a059a0
+size 895564

scrapers/archive_fallbacks.py

@@ -24,8 +24,10 @@ from requests.adapters import HTTPAdapter
 
 log = logging.getLogger("archive_fallbacks")
 
-WAYBACK_CDX = "http://web.archive.org/cdx/search/cdx"
-WAYBACK_WEB = "http://web.archive.org/web"
+WAYBACK_CDX = "http://web.archive.org/cdx/search/cdx"  # https SSLEOF from collector host
+WAYBACK_WEB = "http://web.archive.org/web"  # https SSLEOF from collector host
+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/"
@@ -207,7 +209,11 @@ def _wayback_cdx_page(
             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))
+            try:
+                # Prefer HTTP CDX — HTTPS to archive.org often SSLEOF from this host
+                r = session().get(WAYBACK_CDX_HTTP, params=items, timeout=(20, 90))
+            except requests.RequestException:
+                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)
@@ -283,54 +289,112 @@ def search_wayback_machine(
 
 
 def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
-    """Fetch a snapshot; id_ modifier skips Wayback chrome. No CDX search."""
+    """Fetch a snapshot; id_ modifier skips Wayback chrome. No CDX search.
+
+    Prefer HTTP Wayback via curl (requests follows http→https and SSL-EOFs here).
+    """
+    import subprocess
+
     if timestamp:
-        wb = f"{WAYBACK_WEB}/{timestamp}id_/{url}"
+        path = f"/{timestamp}id_/{url}"
     else:
-        wb = f"{WAYBACK_WEB}/2id_/{url}"
-    r = None
+        path = f"/2id_/{url}"
+    target = WAYBACK_WEB_HTTP + path
     last_err = None
-    for attempt in range(1, 5):
-        _sleep_wayback(1.2 if attempt == 1 else min(20.0, 2.5 * attempt))
+    body = b""
+    ctype = ""
+    final_url = target
+    status = 0
+    for attempt in range(1, 4):
+        _sleep_wayback(0.8 if attempt == 1 else min(8.0, 1.8 * attempt))
         try:
-            r = session().get(wb, timeout=(20, 90), allow_redirects=True)
-        except requests.RequestException as exc:
+            # Stay on HTTP: no -L (redirects flip to https and SSLEOF on this host)
+            proc = subprocess.run(
+                [
+                    "curl", "-fsS", "--max-time", "90",
+                    "-A", UA,
+                    "-w", "\n__HTTP_STATUS__%{http_code}\n__CONTENT_TYPE__%{content_type}\n__URL_EFFECTIVE__%{url_effective}",
+                    "--output", "-",
+                    target,
+                ],
+                capture_output=True,
+                timeout=100,
+            )
+            raw = proc.stdout or b""
+            # Trailer is text appended after body when -w is used with --output -
+            # With --output -, -w goes to stdout after body. Split on trailer markers.
+            marker = b"\n__HTTP_STATUS__"
+            if marker in raw:
+                body, rest = raw.rsplit(marker, 1)
+                trailer = (b"__HTTP_STATUS__" + rest).decode("utf-8", "replace")
+                mstat = re.search(r"__HTTP_STATUS__(\d+)", trailer)
+                mctype = re.search(r"__CONTENT_TYPE__([^\n]*)", trailer)
+                murl = re.search(r"__URL_EFFECTIVE__([^\n]*)", trailer)
+                status = int(mstat.group(1)) if mstat else 0
+                ctype = (mctype.group(1) if mctype else "") or ""
+                final_url = (murl.group(1) if murl else target) or target
+            else:
+                body = raw
+                status = 200 if proc.returncode == 0 and raw else 0
+            if proc.returncode != 0 and not body:
+                last_err = (proc.stderr or b"").decode("utf-8", "replace")[:300] or f"curl_rc_{proc.returncode}"
+                log.info("wayback replay curl fail %s: %s", url, last_err)
+                continue
+            if status in (403, 429, 503, 502, 504) and attempt < 3:
+                log.info("wayback replay HTTP %s %s attempt=%s", status, url, attempt)
+                continue
+            break
+        except Exception 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}
+    else:
+        # fallback: requests without following redirects to https
+        try:
+            r = session().get(target, timeout=(20, 90), allow_redirects=False)
+            status = r.status_code
+            body = r.content or b""
+            ctype = r.headers.get("content-type") or ""
+            final_url = r.url or target
+            if status in (301, 302, 303, 307, 308):
+                loc = r.headers.get("Location") or ""
+                if loc.startswith("https://web.archive.org/"):
+                    loc = "http://" + loc[len("https://"):]
+                if loc.startswith("http://web.archive.org/"):
+                    r2 = session().get(loc, timeout=(20, 90), allow_redirects=False)
+                    status = r2.status_code
+                    body = r2.content or b""
+                    ctype = r2.headers.get("content-type") or ""
+                    final_url = r2.url or loc
+        except requests.RequestException as exc:
+            return {"status": "error", "error": last_err or str(exc), "url": url}
+
+    if not body and status != 200:
+        return {"status": "error", "error": last_err or f"http_{status}", "url": url}
     cap_ts = timestamp or ""
-    m = re.search(r"/web/(\d{14})", r.url or "")
+    m = re.search(r"/web/(\d{14})", final_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:
+        except Exception:
+            text = ""
+    if status != 200 or not body:
         return {
             "status": "error",
-            "error": f"http_{r.status_code}",
-            "http_status": r.status_code,
-            "wayback_url": r.url,
+            "error": f"http_{status}",
+            "http_status": status,
+            "wayback_url": final_url,
             "original_url": url,
         }
-    if text and is_challenge(text, r.status_code):
+    if text and is_challenge(text, status):
         return {
             "status": "error",
             "error": "challenge_or_shell",
-            "http_status": r.status_code,
-            "wayback_url": r.url,
+            "http_status": status,
+            "wayback_url": final_url,
             "original_url": url,
             "content": text[:2000],
         }
@@ -339,42 +403,50 @@ def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
         "content": body,
         "text": text,
         "content_type": ctype,
-        "wayback_url": r.url,
+        "wayback_url": final_url,
         "capture_timestamp": cap_ts,
         "original_url": url,
-        "http_status": r.status_code,
-        "method": "wayback",
+        "http_status": status,
+        "method": "wayback_curl_http",
     }
 
 
 # --- 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:
-        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",
-            ]
+        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]
 
 
@@ -400,8 +472,12 @@ def search_common_crawl(url: str, *, limit: int = 80, indexes: Optional[list[str
         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
+            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)

scrapers/collect_na.py

@@ -1,591 +1,208 @@
 #!/usr/bin/env python3
-"""Namibia: official Bills / Acts / Gazette instruments from Parliament + BoN.
+"""Namibia: official Acts / Bills / Gazette PDFs via *.gov.na + parliament.na.
 
-Primary: laws.parliament.na (Online Bill Tracking — embedded official Bill PDFs),
-www.parliament.na (wp-content Bill / Act PDFs + wp-json media), Bank of Namibia
-(bon.com.na Regulations / Determinations / Act getattachment PDFs).
-
-Skips: lac.org.na (entirely), namiblii.org, SAFLII, gazettes.africa, speeches,
-motivations, contributions, tenders, minutes, notices of award.
-
-Live official URL first; Wayback of the same official URL on failure.
-OCR=1 enables pdftoppm+tesseract for image-only official PDFs. No WAF bypass.
-
-Gaps (recorded): www.gov.na SSL EOF from collector host; moj.gov.na timeout;
-mfpe.gov.na DNS fail; laws.parliament.na/cms_documents live often 404 → Wayback; full Government Gazette series not mirrored on parliament.na.
+Official hosts only: parliament.gov.na, laws.parliament.na, parliament.na,
+gov.na, moj.gov.na, opm.gov.na and other *.gov.na gazette hosts.
+Not AfricanLII / NamibLII / lac.org.na / commercial DBs as source text.
+No WAF bypass. Live-first; Wayback/CDX of official URLs OK (pass CDX timestamps).
 """
 from __future__ import annotations
-
-import base64
-import logging
-import os
-import re
-import subprocess
-import sys
-import tempfile
-import time
+import logging, re, sys, time
 from pathlib import Path
-from urllib.parse import unquote, urljoin, urlparse
-
+from urllib.parse import urljoin, urlsplit, unquote
 sys.path.insert(0, str(Path(__file__).resolve().parent))
-from common import existing_ids, log_failure, utcnow, write_summary
-from world_lib import cdx_urls, env_int, fetch_official, fetch_official_prefer_pdf, live_get, save_instrument, setup_log, slug_id
+from common import existing_ids, http_get, log_failure, utcnow, write_summary
+from world_lib import cdx_urls, env_int, fetch_official, save_instrument, setup_log, slug_id
 
 CC, COUNTRY, LANG = "na", "Namibia", "en"
-SOURCE_TYPE = "namibia_official_parliament_bon"
+SOURCE_TYPE = "namibia_official_gazette_acts"
 LICENSE = (
-    "Laws / Bills / Gazette instruments of Namibia as published on official "
-    "Parliament portals (parliament.na / laws.parliament.na) and Bank of Namibia "
-    "(bon.com.na) statutory hosts. Authentic Government Gazette / Parliament text "
-    "prevails. Not legal advice."
+    "Republic of Namibia — Parliament (parliament.gov.na / laws.parliament.na / "
+    "parliament.na) / Government Portal (gov.na) / Ministry of Justice (moj.gov.na) / "
+    "Office of the Prime Minister (opm.gov.na) and other *.gov.na gazette hosts. "
+    "Authentic Government Gazette / Act text prevails. "
+    "Not AfricanLII / NamibLII / lac.org.na / commercial DBs. Not legal advice."
 )
-UA = "legal-corpora-collector/1.0 (research; source=https://www.parliament.na/)"
+UA = "legal-corpora-collector/1.0 (research; source=https://www.parliament.gov.na/)"
 ART = re.compile(
-    r"(?im)^\s*((?:Section|Sec\.|Article|Art\.|Regulation|Reg\.)\s+\d+[A-Za-z]?\.?)\b"
+    r"(?im)^\s*((?:Article|Art\.?|Section|Sec\.?|Cap\.?|Chapter|Part)\s*[0-9]+)\b"
 )
 log = logging.getLogger("na")
-
-BLOCK_HOST = re.compile(
-    r"(lac\.org\.na|namiblii\.org|saflii\.org|gazettes\.africa|"
-    r"africanlii\.org|commonlii\.org|ulii\.org)",
-    re.I,
-)
-SKIP_NAME = re.compile(
-    r"(contribution|motivation|response|speech|report[_\-\s]|NOTICE[_\-\s]?OF|"
-    r"minutes|tender|award|vacancy|advert|newsletter|workshop|consultative|"
-    r"stakeholder|explanatory[_\-\s]?memorandum|budget[_\-\s]?statement|"
-    r"vote\d|sofa|upholstery|procurement[_\-\s]?notice|selection[_\-\s]?for|"
-    r"cancellation[_\-\s]?of[_\-\s]?a[_\-\s]?bid|facilitator|travel[_\-\s]?management|"
-    r"supply[_\-\s]?and[_\-\s]?delivery|service[_\-\s]?level[_\-\s]?agreement|"
-    r"strategy[_\-\s]?advert|mefmi[_\-\s]?advertisement)",
-    re.I,
+HOMES = [
+    # Live SSL flaky on many *.gov.na / parliament.gov.na; lean live set, lean on CDX/Wayback.
+    "https://laws.parliament.na/",
+    "https://laws.parliament.na/Bill-register",
+    "https://www.parliament.na/",
+    "https://www.parliament.na/bills/",
+    "https://www.parliament.na/acts-of-parliament/",
+]
+# Official Namibia government / parliament hosts (NOT lac.org.na, NOT namiblii)
+ALLOWED = (
+    "gov.na",
+    "parliament.gov.na",
+    "parliament.na",
+    "laws.parliament.na",
 )
-LAWISH_NAME = re.compile(
-    r"("
-    r"\bbill\b|_bill_|-bill-|bill\.pdf|"
-    r"\bact\b|_act_|-act-|act\.pdf|"
-    r"gazette|regulation|regulations|determination|"
-    r"constitution|statutory[_\-\s]?instrument|"
-    r"\bb\.?\s*\d+|amendment"
-    r")",
+DROP_RE = re.compile(
+    r"(africanlii|namiblii|namlii|law\.africa|gazettes\.africa|"
+    r"lac\.org\.na|saflii|commonlii|"
+    r"/news/|/videos?/|interview|"
+    r"facebook|youtube|twitter|logo|banner|photo|recruitment|vacancy|newsletter|"
+    r"tender|procurement|job[_-]?announcement|press[_-]?release|"
+    r"strategic.?plan|annual.?report|brochure|flyer|calendar|factsheet|"
+    r"application.?form|speech|budget.?speech|manifesto|hansard|"
+    r"speakercv|contribution|motivation|minutes|workshop)",
     re.I,
 )
-LAW_MARK = re.compile(
-    r"(BE IT ENACTED|AN ACT\b|A BILL\b|BILL\b|Short title|"
-    r"This Act may be cited|GOVERNMENT GAZETTE|REPUBLIC OF NAMIBIA|"
-    r"ARRANGEMENT OF SECTIONS|NATIONAL ASSEMBLY|PROMULGATION OF ACT|"
-    r"No\.\s*\d+\s+of\s+20\d{2}|\[B\.\s*\d+)",
+KEEP_RE = re.compile(
+    r"(act|acts|bill|statute|ordinance|proclamation|gazette|law|legal|"
+    r"constitution|subsidiary|instrument|regulation|order|cap\.?\s*\d|"
+    r"amendment|decree|statutory.?instrument|\bSI\b|legislation|"
+    r"acts_documents|cms_documents|promulgation)",
     re.I,
 )
-
-CDX_PREFIXES = [
-    "laws.parliament.na/cms_documents/",
-    "www.parliament.na/wp-content/uploads/",
-    "parliament.na/wp-content/uploads/",
-    "www.bon.com.na/CMSTemplates/Bon/Files/",
-    "bon.com.na/CMSTemplates/Bon/Files/",
-]
-
-LIVE_SEEDS = [
-    "https://www.parliament.na/bills/",
-    "https://www.parliament.na/acts-of-parliament/",
-    "https://laws.parliament.na/Bill-register",
-    "https://www.bon.com.na/Regulations.aspx",
-    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks.aspx",
-    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks/Determinations.aspx",
-    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks/Regulations.aspx",
-]
-
-BON_SEED_PAGES = [
-    "https://www.bon.com.na/Regulations.aspx",
-    "https://www.bon.com.na/Regulations/Bank-of-Namibia-Act-2020.aspx",
-    "https://www.bon.com.na/Regulations/Banking-Institutions-Act-2023.aspx",
-    "https://www.bon.com.na/Regulations/Virtual-Assets-Act-2023.aspx",
-    "https://www.bon.com.na/Regulations/Financial-Intelligence-Act-2012.aspx",
-    "https://www.bon.com.na/Regulations/Namibia-Deposit-Guarantee-Act-2018.aspx",
-    "https://www.bon.com.na/Regulations/Payment-System-Management-Act-2003.aspx",
-    "https://www.bon.com.na/Regulations/Payment-System-Management-Amendment-Act-2023.aspx",
-    "https://www.bon.com.na/Regulations/Currencies-and-Exchanges-Act-1933.aspx",
-    "https://www.bon.com.na/Regulations/Prevention-of-Counterfeiting-of-Currency-Act-1965.aspx",
-    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks/Determinations.aspx",
-    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks/Regulations.aspx",
-    "https://www.bon.com.na/Bank/Banking-Supervision/Legal-Frameworks/Other-Bylaws.aspx",
-    "https://www.bon.com.na/Bank/National-Payment-System/Legal-Framework.aspx",
-    "https://www.bon.com.na/Bank/Financial-Stability/Determinations-Regulations-and-Guidance-Notes.aspx",
-]
-
-
-def _norm(url: str) -> str:
-    u = (url or "").split("#")[0]
-    u = u.replace("http://", "https://")
-    u = re.sub(r":80/", "/", u)
-    u = re.sub(r"https://parliament\.na/", "https://www.parliament.na/", u)
-    u = re.sub(r"https://bon\.com\.na/", "https://www.bon.com.na/", u)
-    # Drop tracking query junk; keep empty for getattachment
-    parts = urlparse(u)
-    path = parts.path or ""
-    if " " in unquote(path) or "%" in path:
-        from urllib.parse import quote
-
-        path = quote(unquote(path), safe="/%")
-    return parts._replace(path=path, query="", params="", fragment="").geturl().rstrip("?")
-
-
-def _ident_from_url(url: str) -> str:
-    path = unquote(urlparse(url.split("?")[0]).path)
-    name = Path(path).name
-    if name.lower() in ("", ".aspx", ".aspx/") or name.lower() == ".aspx":
-        # BoN getattachment/<uuid>/.aspx
-        m = re.search(r"getattachment/([0-9a-f-]{36})", url, re.I)
-        if m:
-            name = f"bon-{m.group(1)[:12]}"
-        else:
-            name = Path(path.rstrip("/")).name or "na-doc"
-    if name.lower().endswith(".pdf"):
-        name = name[:-4]
-    if name.lower().endswith(".aspx"):
-        name = name[:-5]
-    name = re.sub(r"\s+", " ", name).strip()
-    return re.sub(r"[^\w.\-]+", "-", name)[:160] or "na-doc"
+MAX_PDF_BYTES = 12 * 1024 * 1024
 
 
 def _host_ok(url: str) -> bool:
-    if not url or not url.startswith("http"):
-        return False
-    if BLOCK_HOST.search(url):
-        return False
-    host = (urlparse(url).hostname or "").lower()
-    ok = (
-        "parliament.na",
-        "bon.com.na",
-        "gov.na",
-        "moj.gov.na",
-        "mfpe.gov.na",
-        "opm.gov.na",
-    )
-    return any(host == s or host.endswith("." + s) for s in ok)
-
-
-def _is_law_url(url: str) -> bool:
-    u = _norm(url)
-    if not _host_ok(u):
-        return False
-    low = unquote(u).lower()
-    if SKIP_NAME.search(low):
+    host = (urlsplit(url).hostname or "").lower()
+    if any(x in host for x in (
+        "africanlii", "namiblii", "namlii", "gazettes.africa",
+        "law.africa", "lac.org.na", "saflii", "commonlii",
+    )):
         return False
-    # Historic laws.parliament.na statute book (live often 404 → Wayback)
-    if "laws.parliament.na" in low and "/cms_documents/" in low and ".pdf" in low:
-        return True
-    # BoN getattachment — accepted when discovered from Act/Determination pages
-    if "parliament.gov.na" in low and "/acts_documents/" in low and ".pdf" in low:
-        return True
-    if "bon.com.na" in low and "/getattachment/" in low:
-        return True
-    if "bon.com.na" in low and "/cmstemplates/bon/files/" in low and ".pdf" in low:
-        return True
-    if ".pdf" not in low:
-        return False
-    name = unquote(urlparse(u.split("?")[0]).path).split("/")[-1]
-    if SKIP_NAME.search(name):
-        return False
-    if LAWISH_NAME.search(name) or LAWISH_NAME.search(low):
+    # Exact / suffix match for allowed suffixes
+    for s in ALLOWED:
+        if host == s or host.endswith("." + s):
+            return True
+    # *.gov.na catch-all (already covered by gov.na suffix, but be explicit)
+    if host.endswith(".gov.na") or host == "gov.na":
         return True
     return False
 
 
-def _title_from_text(text: str, fallback: str) -> str:
-    lines = [ln.strip() for ln in (text or "").splitlines() if ln.strip()]
-    for ln in lines[:60]:
-        if re.search(r"\b(ACT|BILL|REGULATIONS?|GAZETTE|DETERMINATION)\b", ln) and 8 <= len(ln) <= 180:
-            if not re.match(r"^(TITLE|PREVIOUS|NEXT|CONTENTS|EXPLANATORY)\b", ln, re.I):
-                return ln[:240]
-    for ln in lines:
-        if len(ln) >= 12 and not ln.lower().startswith("just a moment"):
-            return ln[:240]
-    return fallback[:240]
-
-
-def _looks_like_law(text: str) -> bool:
-    if not text or len(text) < 200:
-        return False
-    head = text[:10000]
-    if LAW_MARK.search(head):
-        return True
-    secs = len(re.findall(r"(?im)^\s*Section\s+\d+", text[:25000]))
-    return secs >= 5
-
-
-def _add(items: list, seen: set, url: str, ident: str | None = None) -> None:
-    url = _norm(url)
-    if not url or url in seen or not _is_law_url(url):
-        return
-    seen.add(url)
-    items.append((ident or _ident_from_url(url), url))
-
-
-def pdf_ocr_text(raw: bytes, *, max_pages: int = 30, dpi: int = 160) -> str:
-    """OCR scanned / image-only official PDFs via pdftoppm + tesseract (eng)."""
-    if not raw or raw[:4] != b"%PDF":
-        return ""
-    max_pages = env_int("OCR_MAX_PAGES", max_pages)
-    try:
-        with tempfile.TemporaryDirectory() as d:
-            pdf = Path(d) / "in.pdf"
-            pdf.write_bytes(raw)
-            subprocess.run(
-                [
-                    "pdftoppm",
-                    "-png",
-                    "-r",
-                    str(dpi),
-                    "-f",
-                    "1",
-                    "-l",
-                    str(max_pages),
-                    str(pdf),
-                    str(Path(d) / "p"),
-                ],
-                check=False,
-                capture_output=True,
-                timeout=300,
-            )
-            pages = sorted(Path(d).glob("p*.png"))
-            chunks = []
-            for page in pages:
-                proc = subprocess.run(
-                    ["tesseract", str(page), "stdout", "-l", "eng", "--psm", "6"],
-                    capture_output=True,
-                    timeout=180,
-                )
-                if proc.stdout:
-                    chunks.append(proc.stdout.decode("utf-8", "replace"))
-            return "\n".join(chunks).strip()
-    except Exception as exc:
-        log.info("ocr fail: %s", exc)
-        return ""
-
-
-def fetch_na(url: str) -> dict:
-    """Live (+Wayback of same official URL); OCR when OCR=1 for image-only PDFs."""
-    got = fetch_official_prefer_pdf(url, ua=UA, verify=False, min_text=180)
-    if got.get("status") == "success":
-        return got
-    if os.environ.get("OCR", "0") != "1":
-        return got
-    err = got.get("error") or ""
-    body = got.get("content") if isinstance(got.get("content"), (bytes, bytearray)) else b""
-    if not body or body[:4] != b"%PDF":
-        try:
-            r = live_get(url, ua=UA, verify=False, timeout=(15, 90), retries=2)
-            body = r.content or b""
-        except Exception:
-            body = b""
-        if (not body or body[:4] != b"%PDF") and "wayback" not in err:
-            try:
-                import archive_fallbacks as af
-
-                w = af.get_wayback_content(url)
-                if w.get("status") == "success":
-                    body = w.get("content") or b""
-                    if isinstance(body, str):
-                        body = body.encode("latin-1", "replace")
-            except Exception:
-                pass
-    if body and body[:4] == b"%PDF":
-        text = pdf_ocr_text(bytes(body))
-        if len(text) >= 180:
-            got.update(
-                status="success",
-                text=text,
-                content=bytes(body),
-                method=(got.get("method") or "http") + "+ocr",
-                error="",
-            )
-            return got
-        got["error"] = (err or "") + ";ocr_short_or_failed"
-    return got
-
-
-def _decode_data_pdf(html: str) -> bytes:
-    m = re.search(r"data:application/pdf;base64,([A-Za-z0-9+/=\s&#x0-9a-fA-F;]+)", html or "")
-    if not m:
-        return b""
-    b64 = m.group(1)
-    b64 = (
-        b64.replace("&#x2B;", "+")
-        .replace("&#x2F;", "/")
-        .replace("&#x3D;", "=")
-        .replace("&amp;", "&")
-        .replace("&#43;", "+")
-    )
-    b64 = re.sub(r"\s+", "", b64)
-    # strip residual HTML entities
-    b64 = re.sub(r"&#x[0-9a-fA-F]+;", "", b64)
-    b64 = re.sub(r"&#\d+;", "", b64)
-    try:
-        raw = base64.b64decode(b64, validate=False)
-    except Exception:
-        return b""
-    return raw if raw[:4] == b"%PDF" else b""
-
-
-def _harvest_html(url: str) -> list[str]:
-    out = []
-    try:
-        r = live_get(url, ua=UA, verify=False, timeout=(20, 50))
-    except Exception as exc:
-        log.info("seed fail %s: %s", url[:90], exc)
-        return out
-    text = r.text or ""
-    for href in re.findall(r'href=["\']([^"\']+)["\']', text, re.I):
-        full = urljoin(url, href)
-        if ".pdf" in full.lower() or "/getattachment/" in full.lower():
-            out.append(full)
-    for m in re.findall(r'(https?://[^"\'\s>]+\.pdf)', text, re.I):
-        out.append(m)
-    return out
-
-
-def _laws_parliament_bills() -> list[tuple[str, str, str]]:
-    """Return (ident, synthetic_source_url, detail_url) for Bill Tracking PDFs.
-
-    Instruments are stored against the Public/Bills/Details/<uuid> official URL;
-    PDF bytes are embedded as data:application/pdf;base64 on that page.
-    """
-    items, seen = [], set()
-    register = "https://laws.parliament.na/Bill-register"
-    try:
-        r = live_get(register, ua=UA, verify=False, timeout=(25, 70))
-    except Exception as exc:
-        log.info("bill register fail: %s", exc)
-        return items
-    ids = sorted(set(re.findall(r"/Public/Bills/Details/([0-9a-f-]{36})", r.text or "", re.I)))
-    log.info("laws.parliament.na bill ids %s", len(ids))
-    cap = env_int("BILL_DETAILS", 120)
-    for bid in ids[:cap]:
-        detail = f"https://laws.parliament.na/Public/Bills/Details/{bid}"
-        if detail in seen:
-            continue
-        seen.add(detail)
-        # Title from register table if present
-        m = re.search(
-            rf'href=["\']/Public/Bills/Details/{bid}["\'][^>]*>([^<]{{3,120}})',
-            r.text or "",
-            re.I,
-        )
-        label = (m.group(1).strip() if m else "") or f"bill-{bid[:8]}"
-        ident = re.sub(r"[^\w.\-]+", "-", label)[:120] or f"bill-{bid[:8]}"
-        items.append((ident, detail, detail))
-    return items
-
-
-def _fetch_embedded_bill(detail_url: str) -> dict:
-    out = {
-        "status": "error",
-        "text": "",
-        "content": b"",
-        "source_url": detail_url,
-        "method": "",
-        "error": "",
-    }
-    try:
-        r = live_get(detail_url, ua=UA, verify=False, timeout=(30, 120), retries=2)
-    except Exception as exc:
-        out["error"] = f"live:{exc}"
-        return out
-    html = r.text or ""
-    title_m = re.search(r'<h2[^>]*class="[^"]*page-title[^"]*"[^>]*>([^<]+)', html, re.I)
-    page_title = (title_m.group(1).strip() if title_m else "")
-    raw = _decode_data_pdf(html)
-    if not raw:
-        out["error"] = "no_embedded_pdf"
-        return out
-    # text extract
-    from world_lib import pdf_to_text
+def _norm_url(url: str) -> str:
+    url = (url or "").split("#")[0].strip()
+    if url.startswith("http://"):
+        url = "https://" + url[len("http://") :]
+    url = re.sub(r"(https?://[^/:]+):80/", r"\1/", url)
+    # Drop :80 port leftovers
+    url = re.sub(r"(https?://[^/:]+):80(/|$)", r"\1\2", url)
+    return url
 
-    text = pdf_to_text(raw)
-    method = "embedded_pdf"
-    if len(text) < 180 and os.environ.get("OCR", "0") == "1":
-        ocr = pdf_ocr_text(raw)
-        if len(ocr) > len(text):
-            text, method = ocr, "embedded_pdf+ocr"
-    if len(text) < 180:
-        out.update(error="pdf_extract_failed", content=raw)
-        return out
-    out.update(
-        status="success",
-        text=text,
-        content=raw,
-        method=method,
-        source_url=detail_url,
-        page_title=page_title,
-    )
-    return out
 
-
-def _wp_json_media() -> list[tuple[str, str]]:
-    items, seen = [], set()
-    try:
-        import requests
-        from requests.packages.urllib3.exceptions import InsecureRequestWarning
-
-        requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
-    except Exception:
-        return items
-    for page in range(1, env_int("WP_MEDIA_PAGES", 8) + 1):
-        url = (
-            "https://www.parliament.na/wp-json/wp/v2/media"
-            f"?per_page=100&page={page}&mime_type=application/pdf"
-        )
+def discover():
+    """Return list of (ident, url, wayback_ts|None). Live homes first; CDX with timestamps."""
+    items = []  # (priority, ident, url, ts)
+    seen = set()
+
+    def add(url: str, ts: str | None = None, priority: int = 50):
+        url = _norm_url(url)
+        if not url.startswith("http"):
+            return
+        if not _host_ok(url) or DROP_RE.search(url):
+            return
+        if ".pdf" not in url.lower():
+            return
+        blob = unquote(url)
+        if not KEEP_RE.search(blob):
+            if not re.search(
+                r"(?i)/(acts?|laws?|gazette|legislation|publications?|documents?|"
+                r"downloads?|files?|statutory|si[_/\-]|cap[_/\-]|"
+                r"acts_documents|cms_documents|uploads)",
+                blob,
+            ):
+                return
+        key = url.lower()
+        if key in seen:
+            return
+        seen.add(key)
+        ident = re.sub(r"^https?://[^/]+/", "", unquote(url)).replace("/", "-").replace("?", "-")[:160]
+        items.append((priority, ident, url, ts))
+
+    for home in HOMES:
         try:
-            r = requests.get(url, timeout=(20, 50), headers={"User-Agent": UA}, verify=False)
-        except Exception as exc:
-            log.info("wp media fail page %s: %s", page, exc)
-            break
-        if r.status_code != 200:
-            break
-        data = r.json() if r.content else []
-        if not data:
-            break
-        for it in data:
-            su = it.get("source_url") or ""
-            if not su or su in seen:
+            r = http_get(home, ua=UA, sleep=0.25)
+            if getattr(r, "status_code", 0) != 200:
                 continue
-            if not _is_law_url(su):
-                continue
-            seen.add(su)
-            items.append((_ident_from_url(su), su))
-    log.info("wp-json lawish pdfs %s", len(items))
-    return items
-
-
-def _bon_attachments() -> list[tuple[str, str]]:
-    items, seen = [], set()
-    pages = list(BON_SEED_PAGES)
-    # Expand Regulations.aspx child Act pages
-    try:
-        r = live_get("https://www.bon.com.na/Regulations.aspx", ua=UA, verify=False, timeout=(20, 50))
-        for href in re.findall(r'href=["\']([^"\']+)["\']', r.text or "", re.I):
-            full = urljoin("https://www.bon.com.na/Regulations.aspx", href)
-            if re.search(r"/Regulations/[^\"']+(Act|Regulation|Determination)", full, re.I):
-                if full not in pages:
-                    pages.append(full)
-    except Exception as exc:
-        log.info("bon regulations index fail: %s", exc)
-
-    for page in pages[: env_int("BON_PAGES", 40)]:
+            for href in re.findall(r'href=["\']([^"\']+)["\']', r.text or "", re.I):
+                add(urljoin(home, href.replace("&amp;", "&")), ts=None, priority=10)
+            for href in re.findall(r'(https?://[^\s"\'<>]+\.pdf)', r.text or "", re.I):
+                add(href, ts=None, priority=10)
+            for href in re.findall(r'["\'](/[^"\']+\.pdf)["\']', r.text or "", re.I):
+                add(urljoin(home, href), ts=None, priority=10)
+        except Exception as exc:
+            log.info("home %s %s", home, exc)
+
+    cdx_prefixes = (
+        "www.parliament.gov.na/acts_documents/",
+        "parliament.gov.na/acts_documents/",
+        "www.parliament.gov.na/",
+        "parliament.gov.na/",
+        "laws.parliament.na/cms_documents/",
+        "laws.parliament.na/",
+        "www.parliament.na/wp-content/uploads/",
+        "parliament.na/wp-content/uploads/",
+        "www.parliament.na/",
+        "www.gov.na/documents/",
+        "gov.na/documents/",
+        "www.moj.gov.na/",
+        "moj.gov.na/",
+        "www.opm.gov.na/",
+        "opm.gov.na/",
+        "www.mof.gov.na/",
+        "www.mti.gov.na/",
+        "www.mhss.gov.na/",
+        "www.npc.gov.na/",
+    )
+    for prefix in cdx_prefixes:
         try:
-            r = live_get(page, ua=UA, verify=False, timeout=(20, 50))
+            hits = cdx_urls(
+                prefix,
+                limit=env_int("CDX_LIMIT", 220),
+                match_type="prefix",
+                extra_filters=["statuscode:200", "mimetype:application/pdf"],
+            ) or []
         except Exception as exc:
-            log.info("bon page fail %s: %s", page[:80], exc)
-            continue
-        # Prefer labelled Act/Determination attachments near lawish anchor text
-        html = r.text or ""
-        for href in re.findall(r'href=["\']([^"\']*getattachment[^"\']*)["\']', html, re.I):
-            full = _norm(urljoin(page, href))
-            if full in seen:
+            log.info("cdx %s %s", prefix, exc)
+            hits = []
+        for h in hits:
+            orig = h.get("original") or ""
+            ts = (h.get("timestamp") or "")[:14] or None
+            try:
+                length = int(h.get("length") or 0)
+            except Exception:
+                length = 0
+            if length and length > MAX_PDF_BYTES:
                 continue
-            # Skip obvious image/css attachments by fetching later; filter by nearby text
-            seen.add(full)
-            # ident from surrounding context if possible
-            slug = Path(urlparse(page).path).name.replace(".aspx", "")
-            m = re.search(r"getattachment/([0-9a-f-]{36})", full, re.I)
-            uuid = m.group(1)[:12] if m else "att"
-            ident = f"{slug}-{uuid}"[:140]
-            items.append((ident, full))
-    log.info("bon attachments %s", len(items))
-    return items
-
-
-def discover():
-    items, seen = [], set()
-
-    # 1) Live seed harvest (parliament + BoN HTML)
-    for su in LIVE_SEEDS:
-        for href in _harvest_html(su):
-            _add(items, seen, href)
-
-    # 2) Parliament wp-json media (Bill/Act PDFs)
-    for ident, url in _wp_json_media():
-        _add(items, seen, url, ident)
-
-    # 3) BoN Act / Determination / Regulation attachments
-    for ident, url in _bon_attachments():
-        # BoN getattachment always allowed when harvested from Act pages
-        url = _norm(url)
-        if not url or url in seen or not _host_ok(url):
-            continue
-        if BLOCK_HOST.search(url):
-            continue
-        seen.add(url)
-        items.append((ident, url))
-
-    # 4) CDX of official hosts
-    limit = env_int("CDX_LIMIT", 500)
-    for prefix in CDX_PREFIXES:
-        for h in cdx_urls(prefix, limit=limit, match_type="prefix", extra_filters=["mimetype:application/pdf"]):
-            orig = (h.get("original") or "").replace("http://", "https://")
-            _add(items, seen, orig)
-        if len(items) >= env_int("CATALOG_CAP", 500):
-            break
-
-    log.info("catalog pdf/attach %s", len(items))
-    return items
+            pri = 20
+            if re.search(
+                r"(?i)(act|gazette|constitution|statutory|bill|/laws?/|/legislation|acts_documents|cms_documents)",
+                unquote(orig),
+            ):
+                pri = 15
+            add(orig, ts=ts, priority=pri)
+
+    items.sort(key=lambda x: (x[0], x[1]))
+    out = [(ident, url, ts) for _, ident, url, ts in items]
+    log.info("catalog %s", len(out))
+    return out
 
 
 def main():
     setup_log(CC)
     t0 = utcnow()
     max_new = env_int("MAX_NEW", 80)
-    max_seconds = env_int("MAX_SECONDS", 3600)
+    max_seconds = env_int("MAX_SECONDS", 2400)
     t_start = time.time()
     done = existing_ids(CC)
+    already = len(done)
+    target_total = env_int("TARGET_TOTAL", 0)
     ok = skip = fail = 0
-
-    # A) Embedded Bill PDFs from laws.parliament.na (priority — official Bill Tracking)
-    for ident, source_url, detail in _laws_parliament_bills():
+    for ident, url, ts in discover():
         if max_new and ok >= max_new:
             break
-        if time.time() - t_start > max_seconds:
-            break
-        rid = slug_id(CC, ident)
-        if rid in done:
-            skip += 1
-            continue
-        got = _fetch_embedded_bill(detail)
-        text = got.get("text") or ""
-        if got.get("status") != "success":
-            fail += 1
-            log_failure(CC, {"identifier": ident, "source_url": source_url, "reason": got.get("error")})
-            continue
-        if not _looks_like_law(text):
-            fail += 1
-            log_failure(CC, {"identifier": ident, "source_url": source_url, "reason": "not_law_like"})
-            continue
-        title = got.get("page_title") or _title_from_text(text, ident)
-        if save_instrument(
-            cc=CC,
-            country=COUNTRY,
-            language=LANG,
-            ident=ident,
-            title=title,
-            text=text,
-            source_url=source_url,
-            source_type=SOURCE_TYPE,
-            license_text=LICENSE,
-            collector="collect_na.py",
-            article_re=ART,
-            extra_meta={"fetch_method": got.get("method"), "portal": "laws.parliament.na"},
-        ):
-            ok += 1
-            done.add(rid)
-            log.info("ok bill %s chars=%s method=%s", ident[:70], len(text), got.get("method"))
-        else:
-            fail += 1
-
-    # B) Direct PDF / BoN attachment catalog
-    for ident, url in discover():
-        if max_new and ok >= max_new:
+        if target_total and (already + ok) >= target_total:
             break
         if time.time() - t_start > max_seconds:
             break
@@ -593,67 +210,51 @@ def main():
         if rid in done:
             skip += 1
             continue
-        got = fetch_na(url)
+        got = fetch_official(url, ua=UA, min_text=200, wayback_ts=ts)
         text = got.get("text") or ""
         if got.get("status") != "success":
             fail += 1
-            log_failure(CC, {"identifier": ident, "source_url": url, "reason": got.get("error")})
+            log_failure(CC, {"identifier": ident, "source_url": url, "reason": got.get("error"), "wayback_ts": ts})
             continue
-        if not _looks_like_law(text):
+        if len(text) > 2_500_000:
+            log.info("skip huge text chars=%s %s", len(text), ident[:50])
             fail += 1
-            log_failure(CC, {"identifier": ident, "source_url": url, "reason": "not_law_like"})
+            log_failure(CC, {"identifier": ident, "source_url": url, "reason": "text_too_large", "chars": len(text)})
             continue
-        title = _title_from_text(text, ident)
+        title = None
+        for line in text.splitlines():
+            if len(line.strip()) > 18:
+                title = line.strip()[:240]
+                break
         if save_instrument(
-            cc=CC,
-            country=COUNTRY,
-            language=LANG,
-            ident=ident,
-            title=title,
-            text=text,
-            source_url=url,
-            source_type=SOURCE_TYPE,
-            license_text=LICENSE,
-            collector="collect_na.py",
-            article_re=ART,
-            extra_meta={"fetch_method": got.get("method")},
+            cc=CC, country=COUNTRY, language=LANG, ident=ident,
+            title=title or ident, text=text, source_url=url,
+            source_type=SOURCE_TYPE, license_text=LICENSE, collector="collect_na.py",
+            article_re=ART, extra_meta={"fetch_method": got.get("method"), "wayback_ts": ts},
         ):
             ok += 1
             done.add(rid)
-            log.info("ok %s chars=%s method=%s", ident[:70], len(text), got.get("method"))
+            log.info("ok %s method=%s chars=%s ts=%s", ident[:60], got.get("method"), len(text), ts)
         else:
             fail += 1
-
     write_summary(
-        CC,
-        country=COUNTRY,
-        source="Namibia Parliament (parliament.na / laws.parliament.na) + Bank of Namibia",
+        CC, country=COUNTRY,
+        source="Namibia Official Gazette / Acts (parliament.gov.na / laws.parliament.na / gov.na / moj.gov.na / opm.gov.na)",
         source_urls=[
-            "https://www.parliament.na/",
+            "https://www.parliament.gov.na/",
             "https://laws.parliament.na/",
-            "https://laws.parliament.na/Bill-register",
-            "https://www.bon.com.na/Regulations.aspx",
+            "https://www.parliament.na/",
             "https://www.gov.na/",
+            "https://www.moj.gov.na/",
+            "https://www.opm.gov.na/",
         ],
-        license_text=LICENSE,
-        discovered=ok + skip + fail,
-        fetched=ok,
-        skipped=skip,
-        failed=fail,
-        coverage=(
-            "catalog-backed incomplete; lac.org.na skipped by policy; "
-            "gov.na/moj.gov.na/mfpe.gov.na unreachable or SSL-fail from collector host; "
-            "full Government Gazette series not on parliament.na"
-        ),
-        notes=(
-            "Official Bills from laws.parliament.na Bill Tracking (embedded PDFs) and "
-            "parliament.na wp-content; BoN Act/Determination/Regulation getattachment PDFs. "
-            "Skipped lac.org.na / NamibLII / SAFLII. OCR when OCR=1. Not legal advice."
-        ),
+        license_text=LICENSE, discovered=ok + skip + fail, fetched=ok, skipped=skip, failed=fail,
+        coverage="catalog-backed incomplete (PDF-first live+CDX *.gov.na / parliament.na with timestamps)",
+        notes="Official *.gov.na / parliament.na PDFs only. Not AfricanLII/NamibLII/lac.org.na. No WAF bypass. Not legal advice.",
         last_run=t0,
     )
-    log.info("done ok=%s skip=%s fail=%s", ok, skip, fail)
+    log.info("done ok=%s skip=%s fail=%s total_instruments=%s", ok, skip, fail, len(done))
 
 
 if __name__ == "__main__":
-    main()
+    main()

scrapers/common.py

@@ -234,13 +234,11 @@ def xml_to_text(raw: str, skip_tags: Optional[set[str]] = None) -> str:
 
 ARTICLE_SPLIT = re.compile(
     r"(?im)^\s*((?:art(?:icle|ikel|\.)|§|článek|článok|član|artikkel|articolo|"
-    r"artigo|artículo|artykuł|art\.\s*|str\.\s*|para(?:graph)?\.?|szakasz|"
-    r"άρθρο|Άρθρο|ΑΡΘΡΟ)\s+"
-    r"[\dIVXLCDMΑ-Ω]+[a-zA-ZΑ-Ωa-z]?)\b"
+    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 []
@@ -506,3 +504,28 @@ def iso_date(val: Optional[str]) -> Optional[str]:
     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/world_lib.py

@@ -52,50 +52,20 @@ def setup_log(cc: str, name: str | None = None) -> None:
 
 
 def pdf_to_text(raw: bytes) -> str:
-    """Extract text via pdftotext. Tries qpdf --decrypt first for copy-restricted
-    digital PDFs (still not OCR — image-only scans stay empty)."""
-    if not raw:
+    if not raw or raw[:4] != b"%PDF":
         return ""
-    if raw[:4] != b"%PDF":
-        idx = raw.find(b"%PDF")
-        if idx < 0 or idx > 8192:
-            return ""
-        raw = raw[idx:]
     try:
-        with tempfile.TemporaryDirectory() as d:
-            dpath = Path(d)
-            src = dpath / "in.pdf"
-            src.write_bytes(raw)
-            candidates = [src]
-            dec = dpath / "dec.pdf"
-            try:
-                q = subprocess.run(
-                    ["qpdf", "--decrypt", str(src), str(dec)],
-                    check=False,
-                    capture_output=True,
-                    timeout=120,
-                )
-                if q.returncode == 0 and dec.exists() and dec.stat().st_size > 1000:
-                    candidates.insert(0, dec)
-            except Exception:
-                pass
-            best = ""
-            for cand in candidates:
-                for args in (
-                    ["pdftotext", "-layout", "-enc", "UTF-8", str(cand), "-"],
-                    ["pdftotext", "-raw", "-enc", "UTF-8", str(cand), "-"],
-                ):
-                    proc = subprocess.run(
-                        args, check=False, capture_output=True, timeout=180
-                    )
-                    if proc.returncode == 0 and proc.stdout:
-                        text = proc.stdout.decode("utf-8", "replace").strip()
-                        # Ignore form-feed-only / tiny junk from image-only pages
-                        if len(text) > len(best):
-                            best = text
-                if len(best) >= 150:
-                    break
-            return best
+        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 ""
@@ -105,24 +75,18 @@ def split_custom(text: str, law_id: str, source_url: str, date: Optional[str], p
     docs = split_articles(text, law_id, source_url, date)
     if not pattern:
         return docs
-    # Normalize bidi + eastern digits so Arabic/Persian article markers match
-    try:
-        from pdf_extract_lib import normalize_rtl_text
-        work = normalize_rtl_text(text or "")
-    except Exception:
-        work = text or ""
-    matches = list(pattern.finditer(work))
+    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(work)
-        chunk = work[start:end].strip()
+        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\u0600-\u06FF-]+", "-", num.lower()).strip("-")[:80]
+        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],
@@ -141,7 +105,20 @@ def split_custom(text: str, law_id: str, source_url: str, date: Optional[str], p
     return out if len(out) >= 2 else docs
 
 
-def live_get(url: str, *, ua: str = DEFAULT_UA, timeout: tuple = (12, 25), verify: bool = True, retries: int = 2):
+
+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)
@@ -174,6 +151,7 @@ def fetch_official(
     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": "",
@@ -185,20 +163,12 @@ def fetch_official(
     }
     body = b""
     ctype = ""
-    skip_live = os.environ.get("SKIP_LIVE", "0") not in ("0", "false", "False", "")
     try:
-        if skip_live:
-            raise RuntimeError("skip_live")
         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:
-            is_pdf = (
-                body[:4] == b"%PDF"
-                or (0 <= body.find(b"%PDF") <= 64)
-                or "pdf" in ctype.lower()
-            )
-            if is_pdf:
+            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)
@@ -215,12 +185,8 @@ def fetch_official(
                         return out
                     if len(text) < min_text:
                         out["error"] = "short_or_spa"
-            elif body[:4] == b"%PDF" or (0 <= body.find(b"%PDF") <= 64):
-                # Keep bytes so callers (OCR) can work without a second download
-                pdf_body = body if body[:4] == b"%PDF" else body[body.find(b"%PDF"):]
+            elif body[:4] == b"%PDF":
                 out["error"] = "pdf_extract_failed"
-                out["content"] = pdf_body
-                out["content_type"] = ctype or "application/pdf"
             elif len(body) > min_text:
                 try:
                     text = body.decode("utf-8", "replace")
@@ -242,25 +208,8 @@ def fetch_official(
             if w.get("status") == "success":
                 raw_b = w.get("content") or b""
                 raw_t = w.get("text") or ""
-                pdf_bytes = b""
-                if isinstance(raw_b, (bytes, bytearray)) and raw_b:
-                    if raw_b[:4] == b"%PDF":
-                        pdf_bytes = bytes(raw_b)
-                    else:
-                        _idx = raw_b.find(b"%PDF", 0, 8192)
-                        if _idx >= 0:
-                            pdf_bytes = bytes(raw_b[_idx:])
-                if not pdf_bytes and raw_t:
-                    enc = raw_t.encode("latin-1", "replace")
-                    if enc[:4] == b"%PDF":
-                        pdf_bytes = enc
-                    else:
-                        _idx = enc.find(b"%PDF", 0, 8192)
-                        if _idx >= 0:
-                            pdf_bytes = enc[_idx:]
-                if pdf_bytes or (isinstance(raw_b, bytes) and (w.get("content_type") or "").lower().find("pdf") >= 0):
-                    if not pdf_bytes and isinstance(raw_b, bytes):
-                        pdf_bytes = raw_b
+                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(
@@ -268,19 +217,15 @@ def fetch_official(
                             text=text,
                             content=pdf_bytes,
                             method="wayback_pdf",
-                            source_url=w.get("wayback_url") or w.get("url") or url,
+                            source_url=w.get("url") or url,
                             content_type="application/pdf",
                         )
                         return out
-                    # Keep PDF bytes so callers (OCR) can work without a second download
                     out["error"] = (out.get("error") or "") + ";pdf_extract_failed"
-                    out["content"] = pdf_bytes
-                    out["content_type"] = "application/pdf"
-                    out["source_url"] = w.get("wayback_url") or w.get("url") or url
                     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[:400] or "startxref" in raw_t[:800]:
+                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
@@ -302,81 +247,6 @@ def fetch_official(
     return out
 
 
-
-def best_cdx_pdf_timestamp(url: str) -> Optional[str]:
-    """Pick a CDX snapshot timestamp that looks like a real PDF (status 200)."""
-    try:
-        # Prefer exact URL match via prefix of the path
-        from urllib.parse import urlsplit
-        parts = urlsplit(url)
-        host = (parts.hostname or "").replace("www.", "")
-        path = parts.path or "/"
-        # try a few URL variants
-        candidates = []
-        for u in (url, url.replace("https://", "http://"), url.replace("http://", "https://")):
-            u2 = u.replace(":80/", "/")
-            for h in cdx_urls(u2, limit=20, match_type="exact"):
-                candidates.append(h)
-            # also prefix on host+path
-        prefix = f"{host}{path}".lstrip("/")
-        if prefix:
-            for h in cdx_urls(prefix, limit=30, match_type="prefix",
-                              extra_filters=["mimetype:application/pdf"]):
-                candidates.append(h)
-            for h in cdx_urls("www." + prefix, limit=30, match_type="prefix",
-                              extra_filters=["mimetype:application/pdf"]):
-                candidates.append(h)
-        best = None
-        for h in candidates:
-            ts = h.get("timestamp") or ""
-            sc = str(h.get("statuscode") or h.get("status") or "")
-            mt = (h.get("mimetype") or "").lower()
-            orig = (h.get("original") or "").lower()
-            if not ts:
-                continue
-            if sc and sc not in ("200", "226", "-"):
-                continue
-            score = 0
-            if "pdf" in mt or orig.endswith(".pdf"):
-                score += 2
-            if sc == "200":
-                score += 1
-            if best is None or score > best[0] or (score == best[0] and ts > best[1]):
-                best = (score, ts)
-        return best[1] if best else None
-    except Exception as exc:
-        log.info("best_cdx_pdf_timestamp fail %s: %s", url[:80], exc)
-        return None
-
-
-def fetch_official_prefer_pdf(
-    url: str,
-    *,
-    ua: str = DEFAULT_UA,
-    verify: bool = True,
-    min_text: int = MIN_TEXT,
-    wayback_ts: Optional[str] = None,
-) -> dict:
-    """Live first; on failure, Wayback with CDX PDF timestamp when available."""
-    got = fetch_official(url, ua=ua, verify=verify, wayback=True, wayback_ts=wayback_ts, min_text=min_text)
-    if got.get("status") == "success" and not (got.get("text") or "").lstrip().startswith("%PDF"):
-        # reject obvious HTML shells mistaken for success when URL is a PDF
-        if url.lower().endswith(".pdf") and got.get("method") == "wayback_html":
-            pass  # try timestamped below
-        else:
-            return got
-    ts = wayback_ts or best_cdx_pdf_timestamp(url)
-    if ts:
-        got2 = fetch_official(url, ua=ua, verify=verify, wayback=True, wayback_ts=ts, min_text=min_text)
-        if got2.get("status") == "success":
-            return got2
-        # try http variant with same ts
-        alt = url.replace("https://", "http://") if url.startswith("https://") else url.replace("http://", "https://")
-        got3 = fetch_official(alt, ua=ua, verify=verify, wayback=True, wayback_ts=ts, min_text=min_text)
-        if got3.get("status") == "success":
-            return got3
-    return got
-
 def first_title(text: str, fallback: str) -> str:
     for line in (text or "").splitlines():
         s = line.strip()