Refresh Namibia densify (160 laws / 4927 articles; was 80/491; *.gov.na / parliament)

MANIFEST.md

@@ -1,25 +1,25 @@
 # ipfs_namibia_laws manifest
 
-generated_utc: 2026-09-09T07:49:21Z
+generated_utc: 2026-09-10T03:14:29Z
 cc: na
-laws_rows: 80
-articles_rows: 491
-laws_bytes: 895564
-articles_bytes: 733354
-laws_sha256: dcd1094c496a92cb7ca5cfca5490294bbe9c7a9092c3420498f48db7e0a059a0
-articles_sha256: aa8c57ca99695413c69bd0036138938d0a96668a3eeac86061f4162f52f71089
+laws_rows: 160
+articles_rows: 4927
+laws_bytes: 1372965
+articles_bytes: 1370997
+laws_sha256: 39a97d99dd998503eaf73ba00a35b9e0ced1bcf0c8ef7db6f2fad15476f95b72
+articles_sha256: 09272c95ccf068735ffd883401ef02f307f6ef0c7870ca030b98ef2850c40287
 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
+live_instruments: 160
 archive_instruments: 0
 wayback_instruments: 0
 common_crawl_instruments: 0
 archive_is_instruments: 0
-constitution_present: false
+constitution_present: true
 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.

README.md

@@ -18,7 +18,7 @@ tags:
 - acts
 - official-texts
 size_categories:
-- n<1K
+- 1K<n<10K
 configs:
 - config_name: laws
   data_files: data/laws.parquet
@@ -37,12 +37,12 @@ Research snapshot of official national legislation from **Parliament (parliament
 
 | Field | Value |
 | --- | --- |
-| Snapshot date | 2026-09-09 |
+| Snapshot date | 2026-09-10 |
 | 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 | 80 |
-| Articles | 491 |
+| Laws / instruments | 160 |
+| Articles | 4,927 |
 | Language | en |
 | Jurisdiction | Namibia |
 | License | `na-parliament-gov-moj-official-texts` |

data/articles.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:aa8c57ca99695413c69bd0036138938d0a96668a3eeac86061f4162f52f71089
-size 733354
+oid sha256:09272c95ccf068735ffd883401ef02f307f6ef0c7870ca030b98ef2850c40287
+size 1370997

data/laws.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dcd1094c496a92cb7ca5cfca5490294bbe9c7a9092c3420498f48db7e0a059a0
-size 895564
+oid sha256:39a97d99dd998503eaf73ba00a35b9e0ced1bcf0c8ef7db6f2fad15476f95b72
+size 1372965

scrapers/archive_fallbacks.py

@@ -288,10 +288,13 @@ def search_wayback_machine(
     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 via curl (requests follows http→https and SSL-EOFs here).
+    Follow 3xx Location only after rewriting https://web.archive.org → http://.
+    Redirect hops do not consume the HTTP retry budget.
     """
     import subprocess
 
@@ -305,15 +308,19 @@ def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
     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))
+    redirects_left = 8
+    attempts_left = 5
+    first = True
+    while attempts_left > 0:
+        _sleep_wayback(0.35 if not first and redirects_left < 8 else (0.8 if first else min(8.0, 1.8 * (6 - attempts_left))))
+        first = False
         try:
             # Stay on HTTP: no -L (redirects flip to https and SSLEOF on this host)
             proc = subprocess.run(
                 [
-                    "curl", "-fsS", "--max-time", "90",
+                    "curl", "-sS", "--max-time", "90",
                     "-A", UA,
-                    "-w", "\n__HTTP_STATUS__%{http_code}\n__CONTENT_TYPE__%{content_type}\n__URL_EFFECTIVE__%{url_effective}",
+                    "-w", "\n__HTTP_STATUS__%{http_code}\n__CONTENT_TYPE__%{content_type}\n__URL_EFFECTIVE__%{url_effective}\n__REDIRECT_URL__%{redirect_url}",
                     "--output", "-",
                     target,
                 ],
@@ -321,55 +328,95 @@ def get_wayback_content(url: str, timestamp: Optional[str] = None) -> dict:
                 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__"
+            redirect_url = ""
             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)
+                mredir = re.search(r"__REDIRECT_URL__([^\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
+                redirect_url = (mredir.group(1) if mredir else "") or ""
             else:
                 body = raw
                 status = 200 if proc.returncode == 0 and raw else 0
+            if status in (301, 302, 303, 307, 308):
+                loc = (redirect_url or "").strip()
+                if loc.startswith("/"):
+                    loc = "http://web.archive.org" + loc
+                if loc.startswith("https://web.archive.org/"):
+                    loc = "http://" + loc[len("https://"):]
+                if loc.startswith("http://web.archive.org/") and redirects_left > 0:
+                    log.info("wayback replay follow HTTP redirect %s -> %s", status, loc[:120])
+                    target = loc
+                    final_url = loc
+                    redirects_left -= 1
+                    continue  # redirect hop: do not consume attempts_left
+                last_err = f"http_{status}_bad_redirect"
+                log.info("wayback replay HTTP %s bad redirect %s", status, (loc or "")[:160])
+                attempts_left -= 1
+                continue
             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)
+                attempts_left -= 1
                 continue
-            if status in (403, 429, 503, 502, 504) and attempt < 3:
-                log.info("wayback replay HTTP %s %s attempt=%s", status, url, attempt)
+            if status in (403, 429, 503, 502, 504) and attempts_left > 1:
+                log.info("wayback replay HTTP %s %s attempts_left=%s", status, url, attempts_left)
+                attempts_left -= 1
                 continue
             break
         except Exception as exc:
             last_err = str(exc)
             log.info("wayback replay fail %s: %s", url, exc)
+            attempts_left -= 1
             continue
     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 ""
+            hops = 0
+            while hops < 8:
+                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 not in (301, 302, 303, 307, 308):
+                    break
+                loc = (r.headers.get("Location") or "").strip()
+                if loc.startswith("/"):
+                    loc = "http://web.archive.org" + loc
                 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
+                if not loc.startswith("http://web.archive.org/"):
+                    last_err = f"http_{status}_bad_redirect"
+                    break
+                target = loc
+                final_url = loc
+                hops += 1
         except requests.RequestException as exc:
             return {"status": "error", "error": last_err or str(exc), "url": url}
 
-    if not body and status != 200:
+    if (not body and status != 200) or status == 404:
+        # /2id_/ sometimes lands on a missing capture; pick an explicit CDX 200 snapshot.
+        if not timestamp:
+            try:
+                hits = search_wayback_machine(url, limit=5, filter_status="200", collapse="digest")
+                for hit in hits:
+                    ts = hit.get("timestamp") or ""
+                    orig = hit.get("original") or url
+                    if not ts:
+                        continue
+                    alt = get_wayback_content(orig, timestamp=ts)
+                    if alt.get("status") == "success" and (alt.get("content") or b""):
+                        return alt
+                    # also try original host/path casing from CDX
+            except Exception as exc:
+                log.info("wayback cdx retry after http_%s: %s", status, exc)
         return {"status": "error", "error": last_err or f"http_{status}", "url": url}
     cap_ts = timestamp or ""
     m = re.search(r"/web/(\d{14})", final_url or "")

scrapers/collect_na.py

@@ -5,14 +5,45 @@ 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).
+
+Densify: Namibia Acts use Commonwealth ``1. Definitions`` / ``1. Short title.``
+section numbering (not only ``Section N`` / ``PART N``). Prefer enacting body
+after BE IT ENACTED / ARRANGEMENT OF SECTIONS to avoid TOC double-count
+(Namibia often places the arrangement *after* the enacting formula).
 """
 from __future__ import annotations
-import logging, re, sys, time
+
+import json
+import logging
+import os
+import re
+import sys
+import time
 from pathlib import Path
 from urllib.parse import urljoin, urlsplit, unquote
+
 sys.path.insert(0, str(Path(__file__).resolve().parent))
-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
+from common import (
+    INDEX_FIELDS,
+    ROOT,
+    atomic_write,
+    base_record,
+    existing_ids,
+    http_get,
+    log_failure,
+    utcnow,
+    write_instrument,
+    write_summary,
+)
+from world_lib import (
+    cdx_urls,
+    env_int,
+    fetch_official,
+    first_title,
+    setup_log,
+    slug_id,
+    split_custom,
+)
 
 CC, COUNTRY, LANG = "na", "Namibia", "en"
 SOURCE_TYPE = "namibia_official_gazette_acts"
@@ -24,9 +55,29 @@ LICENSE = (
     "Not AfricanLII / NamibLII / lac.org.na / commercial DBs. Not legal advice."
 )
 UA = "legal-corpora-collector/1.0 (research; source=https://www.parliament.gov.na/)"
+
+# Commonwealth body: "1. Definitions" / "12A. Interpretation." / margin "Definitions.  1. In this Act"
+# PLUS classic Section/Article/Regulation N
 ART = re.compile(
-    r"(?im)^\s*((?:Article|Art\.?|Section|Sec\.?|Cap\.?|Chapter|Part)\s*[0-9]+)\b"
+    r"(?im)^\s*(?:[A-Z][A-Za-z0-9 \-]{1,45}\.\s+)?"
+    r"((?:Article|Art\.?|Section|Sec\.?|Regulation|Reg\.)\s+[0-9]+[A-Za-z]?|"
+    r"\d+[A-Za-z]?\.)"
+    r"(?=\s+(?:[A-Z\"'(]|In |This |These |The |For ))"
 )
+ART_ONLY = re.compile(r"(?im)^\s*((?:Article|Art\.?)\s+[0-9]+[A-Za-z]?)\b")
+
+ACT_TEXT_RE = re.compile(
+    r"(?i)(AN ACT\b|A BILL\b|BE IT ENACTED|ARRANGEMENT OF|"
+    r"This Act (?:may be cited|is called|shall be called)|Short title|"
+    r"GOVERNMENT GAZETTE|Annotated Statutes|"
+    r"CONSTITUTION OF|Republic of Namibia)"
+)
+ACT_URL_RE = re.compile(
+    r"(?i)(/act[-_ ]|\bact[-_ ]|_act\.|-act\.|act\.pdf|constitution|"
+    r"/bill[-_ ]|_bill\.|-bill\.|regulation|gazette|statutory|"
+    r"acts_documents|cms_documents|promulgation)"
+)
+
 log = logging.getLogger("na")
 HOMES = [
     # Live SSL flaky on many *.gov.na / parliament.gov.na; lean live set, lean on CDX/Wayback.
@@ -36,7 +87,6 @@ HOMES = [
     "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",
@@ -66,16 +116,23 @@ MAX_PDF_BYTES = 12 * 1024 * 1024
 
 def _host_ok(url: str) -> bool:
     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",
-    )):
+    if any(
+        x in host
+        for x in (
+            "africanlii",
+            "namiblii",
+            "namlii",
+            "gazettes.africa",
+            "law.africa",
+            "lac.org.na",
+            "saflii",
+            "commonlii",
+        )
+    ):
         return False
-    # 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
@@ -86,11 +143,199 @@ def _norm_url(url: str) -> str:
     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
 
 
+def prefer_enacting_body(text: str) -> str:
+    """Skip arrangement/TOC so article split targets operative sections.
+
+    Namibia often: BE IT ENACTED … then ARRANGEMENT OF SECTIONS (TOC), then body.
+    Older gazettes wrap the enacting formula across lines.
+    """
+    if not text:
+        return text
+
+    arr = list(re.finditer(r"(?i)ARRANGEMENT OF (?:SECTIONS|ACT|REGULATIONS)", text))
+    if arr:
+        after = text[arr[-1].end() :]
+        body_ones = list(
+            re.finditer(
+                r"(?im)^\s*(?:[A-Z][A-Za-z0-9 \-]{1,45}\.\s+)?"
+                r"1\.\s+(?:In this Act|This Act|These Regulations|These regulations|"
+                r"Unless the context|For the purposes|\(1\))",
+                after,
+            )
+        )
+        if body_ones:
+            return after[body_ones[0].start() :]
+        parts = list(re.finditer(r"(?im)^\s*PART\s+(?:1|I)\b", after))
+        if len(parts) >= 2:
+            return after[parts[1].start() :]
+        ones = list(
+            re.finditer(
+                r"(?im)^\s*1\.\s+(?:Short title|Citation|Definitions|Interpretation)\b",
+                after,
+            )
+        )
+        if len(ones) >= 2:
+            return after[ones[1].start() :]
+        heads = list(
+            re.finditer(
+                r"(?im)^\s*(Definitions|Interpretation|Short title(?: and commencement)?)\s*$",
+                after,
+            )
+        )
+        if len(heads) >= 2:
+            return after[heads[1].start() :]
+        m = re.search(r"(?im)^\s*1\.\s+\(1\)", after)
+        if m:
+            return after[m.start() :]
+
+    m = re.search(
+        r"(?is)BE IT ENACTED\b.{0,160}?as follows\s*[:-]?",
+        text,
+    )
+    if m and m.end() < len(text) - 200:
+        rest = text[m.end() :]
+        if not re.search(r"(?i)ARRANGEMENT OF", rest[:1500]):
+            return rest
+
+    body_ones = list(
+        re.finditer(
+            r"(?im)^\s*(?:[A-Z][A-Za-z0-9 \-]{1,45}\.\s+)?"
+            r"1\.\s+(?:In this Act|This Act|These Regulations|These regulations)\b",
+            text,
+        )
+    )
+    if body_ones:
+        return text[body_ones[-1].start() :] if len(body_ones) >= 2 else text[body_ones[0].start() :]
+
+    ones = list(re.finditer(r"(?im)^\s*1\.\s+(?:Short title|Citation|Definitions)\b", text))
+    if len(ones) >= 2:
+        return text[ones[1].start() :]
+    parts = list(re.finditer(r"(?im)^\s*PART\s+(?:1|I)\b", text))
+    if len(parts) >= 2:
+        return text[parts[1].start() :]
+    return text
+
+
+def split_na_articles(text: str, rid: str, source_url: str, date=None) -> list:
+    """Commonwealth ``1. Title.`` body split by default; constitutions prefer Article N."""
+    body = prefer_enacting_body(text)
+    docs_sec = split_custom(body, rid, source_url, date, ART)
+    docs_art = split_custom(body, rid, source_url, date, ART_ONLY)
+    blob = f"{rid}|{source_url}"
+    is_const = bool(re.search(r"(?i)constitution", blob)) and not bool(
+        re.search(r"(?i)amm?endment", blob)
+    )
+    if is_const:
+        if len(docs_art) >= 20:
+            return docs_art
+        if len(docs_art) >= 2 and len(docs_sec) > max(20, len(docs_art) * 3):
+            return docs_art
+        if len(docs_art) < 2:
+            return docs_art
+    if len(docs_art) >= 50 and len(docs_art) > len(docs_sec) * 1.2:
+        return docs_art
+    return docs_sec
+
+
+def save_na_instrument(
+    *,
+    ident: str,
+    title: str,
+    text: str,
+    source_url: str,
+    extra_meta: dict | None = None,
+) -> bool:
+    if not text or len(text) < 80:
+        return False
+    rid = slug_id(CC, ident)
+    docs = split_na_articles(text, rid, source_url, None)
+    meta = {
+        "fetch_method": (extra_meta or {}).get("fetch_method"),
+        "article_split": "commonwealth-body",
+    }
+    if extra_meta:
+        meta.update(extra_meta)
+    rec = base_record(
+        cc=CC,
+        country=COUNTRY,
+        language=LANG,
+        ident=ident,
+        title=title or first_title(text, ident),
+        text=text,
+        source_url=source_url,
+        source_type=SOURCE_TYPE,
+        license_text=LICENSE,
+        collector="collect_na.py",
+        documents=docs,
+        extra_meta=meta,
+    )
+    write_instrument(CC, rec)
+    return True
+
+
+def reprocess_existing() -> int:
+    """Re-split articles on Act-like instruments with Commonwealth section regex."""
+    inst = ROOT / CC / "instruments"
+    improved = 0
+    for p in sorted(inst.glob("*.json")):
+        try:
+            rec = json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        text = rec.get("text") or ""
+        if len(text) < 200:
+            continue
+        name = p.name
+        blob = f"{name}|{rec.get('title') or ''}|{rec.get('source_url') or ''}|{text[:2500]}"
+        if not (ACT_TEXT_RE.search(blob) or ACT_URL_RE.search(blob)):
+            continue
+        rid = rec.get("id") or p.stem
+        url = rec.get("source_url") or ""
+        date = rec.get("date")
+        docs = split_na_articles(text, rid, url, date)
+        old = int(rec.get("article_count") or len(rec.get("documents") or []) or 0)
+        new = len(docs)
+        if new <= old and old > 0:
+            continue
+        if new < 2 and old >= new:
+            continue
+        rec["documents"] = docs
+        rec["article_count"] = new
+        rec["article_extraction_status"] = "ok" if docs else "missing"
+        meta = rec.get("metadata") or {}
+        meta["article_reprocess"] = "collect_na.py-commonwealth-sections"
+        meta["article_split"] = "commonwealth-body"
+        rec["metadata"] = meta
+        atomic_write(p, json.dumps(rec, ensure_ascii=False, indent=2) + "\n")
+        improved += 1
+        log.info("reprocess %s %s->%s", rid[:70], old, new)
+    return improved
+
+
+def rebuild_index() -> int:
+    inst = ROOT / CC / "instruments"
+    rows = []
+    for p in sorted(inst.glob("*.json")):
+        try:
+            rec = json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        line = {k: rec.get(k) for k in INDEX_FIELDS if k not in ("path", "bytes", "article_count")}
+        line["path"] = f"instruments/{p.name}"
+        line["article_count"] = rec.get("article_count") or len(rec.get("documents") or [])
+        line["bytes"] = p.stat().st_size
+        line["id"] = rec.get("id") or p.stem
+        rows.append(line)
+    out = ROOT / CC / "index.jsonl"
+    atomic_write(out, "".join(json.dumps(r, ensure_ascii=False) + "\n" for r in rows))
+    log.info("rebuilt index lines=%s", len(rows))
+    return len(rows)
+
+
 def discover():
     """Return list of (ident, url, wayback_ts|None). Live homes first; CDX with timestamps."""
     items = []  # (priority, ident, url, ts)
@@ -137,6 +382,8 @@ def discover():
     cdx_prefixes = (
         "www.parliament.gov.na/acts_documents/",
         "parliament.gov.na/acts_documents/",
+        "www.parliament.gov.na/bills_documents/",
+        "parliament.gov.na/bills_documents/",
         "www.parliament.gov.na/",
         "parliament.gov.na/",
         "laws.parliament.na/cms_documents/",
@@ -154,12 +401,13 @@ def discover():
         "www.mti.gov.na/",
         "www.mhss.gov.na/",
         "www.npc.gov.na/",
+        "www.lac.gov.na/",  # only if *.gov.na — lac.org.na blocked by host check
     )
     for prefix in cdx_prefixes:
         try:
             hits = cdx_urls(
                 prefix,
-                limit=env_int("CDX_LIMIT", 220),
+                limit=env_int("CDX_LIMIT", 280),
                 match_type="prefix",
                 extra_filters=["statuscode:200", "mimetype:application/pdf"],
             ) or []
@@ -176,11 +424,21 @@ def discover():
             if length and length > MAX_PDF_BYTES:
                 continue
             pri = 20
-            if re.search(
-                r"(?i)(act|gazette|constitution|statutory|bill|/laws?/|/legislation|acts_documents|cms_documents)",
-                unquote(orig),
-            ):
-                pri = 15
+            blob = unquote(orig)
+            if re.search(r"(?i)acts_documents|/_?act[_-]?\d|act_\d+_of_\d{4}|constitution", blob):
+                pri = 5
+            elif re.search(r"(?i)(bill|gazette|statutory|/laws?/|/legislation)", blob):
+                pri = 12
+            elif re.search(r"(?i)cms_documents", blob):
+                # Prefer post-independence / Act-labelled CMS; bury colonial-era noise
+                if re.search(r"(?i)(act|amendment|constitution|proclamation)", blob) and not re.search(
+                    r"(?i)(15[0-9]{2}|16[0-9]{2}|17[0-9]{2}|18[0-9]{2}|19[0-5][0-9])", blob
+                ):
+                    pri = 14
+                else:
+                    pri = 35
+            elif re.search(r"(?i)(act|regulation)", blob):
+                pri = 18
             add(orig, ts=ts, priority=pri)
 
     items.sort(key=lambda x: (x[0], x[1]))
@@ -194,10 +452,25 @@ def main():
     t0 = utcnow()
     max_new = env_int("MAX_NEW", 80)
     max_seconds = env_int("MAX_SECONDS", 2400)
+    do_reprocess = os.environ.get("REPROCESS", "1") not in ("0", "false", "no")
+
+    if do_reprocess:
+        n = reprocess_existing()
+        log.info("reprocess improved=%s", n)
+
     t_start = time.time()
     done = existing_ids(CC)
     already = len(done)
     target_total = env_int("TARGET_TOTAL", 0)
+    have_urls = set()
+    for p in (ROOT / CC / "instruments").glob("*.json"):
+        try:
+            u = _norm_url(json.loads(p.read_text(encoding="utf-8")).get("source_url") or "")
+            if u:
+                have_urls.add(u.lower())
+        except Exception:
+            pass
+
     ok = skip = fail = 0
     for ident, url, ts in discover():
         if max_new and ok >= max_new:
@@ -207,7 +480,8 @@ def main():
         if time.time() - t_start > max_seconds:
             break
         rid = slug_id(CC, ident)
-        if rid in done:
+        nu = _norm_url(url).lower()
+        if rid in done or nu in have_urls:
             skip += 1
             continue
         got = fetch_official(url, ua=UA, min_text=200, wayback_ts=ts)
@@ -221,24 +495,42 @@ def main():
             fail += 1
             log_failure(CC, {"identifier": ident, "source_url": url, "reason": "text_too_large", "chars": len(text)})
             continue
-        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 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},
+        title = first_title(text, ident)
+        blob = f"{ident}|{title}|{url}|{text[:2500]}"
+        # Prefer Act-ish PDFs; skip obvious non-law once we have a base set
+        if ok >= 10 and not ACT_TEXT_RE.search(blob) and not ACT_URL_RE.search(url):
+            if not re.search(r"(?i)\b(ACT|BILL|STATUTE|ORDINANCE|CONSTITUTION|GAZETTE|REGULATION)\b", text[:3000]):
+                skip += 1
+                log.info("skip non-act post-fetch %s", ident[:60])
+                continue
+        if save_na_instrument(
+            ident=ident,
+            title=title,
+            text=text,
+            source_url=_norm_url(url),
+            extra_meta={"fetch_method": got.get("method"), "wayback_ts": ts},
         ):
             ok += 1
             done.add(rid)
+            have_urls.add(nu)
             log.info("ok %s method=%s chars=%s ts=%s", ident[:60], got.get("method"), len(text), ts)
         else:
             fail += 1
+
+    rebuild_index()
+    arts = 0
+    n_inst = 0
+    for p in (ROOT / CC / "instruments").glob("*.json"):
+        try:
+            rec = json.loads(p.read_text(encoding="utf-8"))
+        except Exception:
+            continue
+        n_inst += 1
+        arts += int(rec.get("article_count") or len(rec.get("documents") or []) or 0)
+
     write_summary(
-        CC, country=COUNTRY,
+        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.gov.na/",
@@ -248,12 +540,20 @@ def main():
             "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 (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.",
+        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; commonwealth section densify)",
+        notes=(
+            f"Official *.gov.na / parliament.na PDFs only. Commonwealth 1. section split + "
+            f"enacting-body prefer. instruments={n_inst} articles={arts}. "
+            f"Not AfricanLII/NamibLII/lac.org.na. No WAF bypass. Not legal advice."
+        ),
         last_run=t0,
     )
-    log.info("done ok=%s skip=%s fail=%s total_instruments=%s", ok, skip, fail, len(done))
+    log.info("done ok=%s skip=%s fail=%s instruments=%s articles=%s", ok, skip, fail, n_inst, arts)
 
 
 if __name__ == "__main__":

scrapers/world_lib.py

@@ -217,15 +217,28 @@ def fetch_official(
                             text=text,
                             content=pdf_bytes,
                             method="wayback_pdf",
-                            source_url=w.get("url") or url,
+                            source_url=w.get("wayback_url") or w.get("url") or url,
                             content_type="application/pdf",
                         )
                         return out
+                    # Keep PDF bytes so caller can OCR (image-only / bad text layer)
+                    out.update(
+                        content=pdf_bytes,
+                        content_type="application/pdf",
+                        method="wayback_pdf_bytes",
+                        source_url=w.get("wayback_url") or w.get("url") or url,
+                    )
                     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]:
+                    # Treat as PDF bytes for OCR upstream
+                    pdf_bytes = raw_b if isinstance(raw_b, bytes) else raw_t.encode("latin-1", "replace")
+                    if isinstance(pdf_bytes, bytes) and b"%PDF" in pdf_bytes[:8192]:
+                        if pdf_bytes[:4] != b"%PDF":
+                            pdf_bytes = pdf_bytes[pdf_bytes.find(b"%PDF"):]
+                        out.update(content=pdf_bytes, content_type="application/pdf", method="wayback_pdf_bytes")
                     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