mu_b1: AGO consolidated Acts diff-limited append (+526 laws / +16,881 articles -> 723 laws / 22,815 articles); scrapers/mu_b1 bundle

MANIFEST.md

@@ -24,3 +24,17 @@ catalog_expected: None
 catalog_gap: 
 gaps: Official Mauritius (cc=mu) Acts/Bills/SI/Gazette/Constitution PDFs from attorneygeneral.govmu.org, nationalassembly.govmu.org, mauritiusassembly.govmu.org, supremecourt.govmu.org and govmu.org only. Live-first; Wayback/CDX of official *.govmu.org / *.gov.mu URLs on fail. NOT AfricanLII / MauritiusLII. No WAF bypass. Distinct from Seychelles (sc), Comoros (km), Madagascar (mg). Not legal advice.
 uploaded: false
+
+## batch mu_b1 (diff-limited append)
+
+- parent: 80f8c63175886c85a94669f825086cee6c322009
+- laws_rows: 723 (tip 197, new 526)
+- articles_rows: 22815 (tip 5934, new 16881)
+- laws_sha256: 4045d9a063c367d264f20cdf0035e443787ddd82a20710cd6eed371f28ca9a1e
+- articles_sha256: e99b82992ad3cc6faac0e702fab5b44f75f58c1843f5d91fe4b2692f6de4e664
+- compression: zstd; row groups 1 (copied from the tip)
+- collector: scrapers/mu_b1/collect_mu.py (pipeline scrapers/mu_b1/pipeline_mu.sh)
+- drops: {"empty_text": 36, "duplicate_act_in_batch": 49, "duplicate_of_tip": 10}
+- heading-only rows dropped 1036; repeal placeholders kept 455; schedules 379; whole-text fallback 36
+- MANIFEST.json / provenance/changes.json: not present on the parent commit (not created by this batch)
+- checksums: SHA256SUMS

README.md

@@ -40,8 +40,8 @@ Research snapshot of official national legislation from **Attorney General's Off
 | Coverage | catalog-backed incomplete (attorneygeneral.govmu.org + nationalassembly/mauritiusassembly.govmu.org + supremecourt.govmu.org + govmu.org live+CDX; PDFs >12MB skipped) |
 | Source | Attorney General's Office (attorneygeneral.govmu.org) + National Assembly (nationalassembly.govmu.org / mauritiusassembly.govmu.org) + Supreme Court (supremecourt.govmu.org) + govmu.org |
 | Collector | `scrapers/collect_mu.py` |
-| Laws / instruments | 197 |
-| Articles | 5,934 |
+| Laws / instruments | 723 |
+| Articles | 22,815 |
 | Language | en |
 | Jurisdiction | Mauritius |
 | License | `mu-ago-assembly-supremecourt-official-texts` |
@@ -76,3 +76,32 @@ Additive update on top of `endomorphosis/ipfs_mauritius_laws`@94566e522d28: laws
 - Article rows are an exact partition of the law text at numbered article/section markers; laws with no clean markers have no article rows.
 - Per-row provenance (source URL, crawl, dropped candidates and reasons, title/language repairs, audit fixes) is in `provenance/changes.json`; file hashes in `MANIFEST.json`.
 - Research compilation of public legal texts. The official gazette / authentic text prevails. Not legal advice.
+
+## Batch mu_b1 update (AGO consolidated Acts A-Z)
+
+Diff-limited append on top of `endomorphosis/ipfs_mauritius_laws`@80f8c6317588: laws/articles 197/5,934 -> 723/22,815 (new instruments 526, new article rows 16,881). Every row already in the dataset is kept unchanged; new rows follow them.
+
+- Source: the Attorney General's Office 'Acts A-Z' pages (attorneygeneral.govmu.org, Laws of Mauritius), one consolidated PDF per Act (Revised Laws of Mauritius layout). Live official pages only; robots.txt checked on every hop; no archives, logins or forms.
+- New rows carry `source_type` = `mauritius_ago_revised_laws_acts_az` and `metadata_json.batch` = `mu_b1` (listing page, file name, PDF sha256, Last-Modified, bounds, printed Act number line).
+- Duplicates dropped: identical PDFs, the same Act listed twice under two file names (newest copy kept) and Acts already in this dataset (normalised title + year); see `manifests/mu_b1_drops.jsonl`.
+- Every new article `text` is a verbatim slice `laws.text[char_start:char_end]` (offsets in the article's `metadata_json`, ascending). Arrangement-of-sections lines with no body are not articles (listed in `manifests/known_gaps.json`); repealed/spent sections printed as 'Repealed by ...' or 'N. —' are kept with `metadata_json.body_status` = `repealed_placeholder`; Schedules are separate `-sch` articles.
+- The Act number and year in the listing/file name are checked against the printed title block; mismatches are listed in `manifests/known_gaps.json` (the printed value is used).
+- Free-webmail addresses are redacted as `[redacted-webmail]` (`manifests/webmail_redactions.json`, offsets only).
+- `scrapers/mu_b1/`: complete code for this batch with a how-to-run README; pinned versions in `scrapers/requirements.txt`; file hashes in `manifests/mu_b1_code.json`; `SHA256SUMS` covers every file of the pack.
+
+### License / reuse (batch mu_b1)
+
+Consolidated Acts of Mauritius as published by the Attorney General's Office (attorneygeneral.govmu.org). Described, not quoted: the site's Term of Use lets people make personal copies and printouts of the legislation under the Copyright Act, but publishing, disseminating or incorporating it for commercial use needs the prior approval of the Solicitor General; the site also says that only the LexisNexis 2016 Revised Laws of Mauritius (with their supplements) are the authoritative text, so these copies are for information only. Terms: https://attorneygeneral.govmu.org/Pages/Laws%20of%20Mauritius/Constitution/termofuse.aspx . Not legal advice.
+
+### OCR and text quality (batch mu_b1)
+
+- Text source: the PDFs' own text layer (pdftotext -layout) for 502 instruments; tesseract OCR (eng, system tessdata) for 24.
+- DEGRADED means: OCR mean word confidence below 80, or more than 8 % of a text layer's characters outside printable Latin text.
+- Whole-text fallback (no usable numbered sections, or one section dominating): 36 instruments (listed in `manifests/known_gaps.json`).
+
+DEGRADED items: none.
+
+### Known gaps (batch mu_b1)
+
+- The A-Z pages are the AGO's consolidated set; Acts passed after the last consolidation on the site may be missing or not yet consolidated.
+- Drops by reason: duplicate_act_in_batch 49, duplicate_of_tip 10, empty_text 36.

SHA256SUMS

@@ -0,0 +1,33 @@
+74580987e2ef0f3df46e8834880cbe5c6f591e884b9231c84e43fee41b034624  MANIFEST.md
+8a56053306aa49e6632cb0bc8be3eeb9520182e99cd2369a4ef7ded6fd26be00  README.md
+e99b82992ad3cc6faac0e702fab5b44f75f58c1843f5d91fe4b2692f6de4e664  data/articles.parquet
+4045d9a063c367d264f20cdf0035e443787ddd82a20710cd6eed371f28ca9a1e  data/laws.parquet
+e492b8793ef2d2e9591ebff13dfbee0785871c82e4fd13c6fd76ef3390ad804e  manifests/changed_ids.json
+3f9e49f0fa110da07ab7da296812b78b89e790e31ef2d9990e39637a2158f25b  manifests/known_gaps.json
+10381964d9ca2a0d4bdc039a5e2982b78e3105d4a19e3177c8f4b90f1fd0e3f4  manifests/mu_b1_code.json
+32c20f64f37682234c2e176a863e7d9e7b09f872bd9a10c31472dd5012a52dd5  manifests/mu_b1_drops.jsonl
+4d9f846e8839b0e9cba30165b400621c35964a293aaa45fb66bcb38301e8c334  manifests/mu_b1_pii_scan.json
+ebf3f8d01754d7c1797dcd3113b6df279ed75d75703c1f8db31125de8638ed7a  manifests/mu_b1_summary.json
+22e6ecc6b9b988d6e646fdc1b1ce0fcc575c218ef6b6fc900027f6ffb5c7ccf7  manifests/pii_scan_notes.md
+091a771025f44f34582d605b0b4dcc75df52bac1310bfefc5ee7f6de7f3c6836  manifests/webmail_redactions.json
+e5b59be89063d70973109e5c0d1e40292aca55d33faf8e22cbf9eb4871255b60  scrapers/mu_b1/README.md
+3666a01e0aacada4f37fd727cfbb0dd4401c1c7611788ed7ddfa87eb51afee40  scrapers/mu_b1/articles_mu.py
+d0b5bb288e11db24ff4b9ba10f9044bed52b2a836e6a33af30ca335cc5240779  scrapers/mu_b1/br_waiting.sh
+d1a2050ece0e8030fa06d1595ef149b17fccc290d998116c9368f33d8e67efe0  scrapers/mu_b1/challenge_detector_v2.py
+2ef0a6427fb829855d4167d9ac10a1fa8676ddc72a834049bc0d9a929f165dfe  scrapers/mu_b1/classify_mu.py
+ece509d861a2d71600ebda5af0ee19ab830aa8f8e0ebe2ce0ae3e7d942c68d39  scrapers/mu_b1/collect_mu.py
+3cb0c44612fe290f13cc8154555c2afe065c3b8a36a091dee63b4d20104e8bb0  scrapers/mu_b1/extract_mu.py
+763513542d94c7cd4259b8b4120e692319305cbf6ed174176de112e433ee7e06  scrapers/mu_b1/finalize_mu.py
+d855c2da5a06029077ec55c76bdf5930c62e1e2fc48a5d7911bb006cdf8c08f8  scrapers/mu_b1/mu_net.py
+c6f4cad70e5d8a031f0fba2b3c610eb407084307f09e2727636cc4e8abd404a8  scrapers/mu_b1/ocr_mu.py
+588e5f4888c0b3c7b8b16dbeb61ae6443d3983bb737fa0d857c2c14ab7d78667  scrapers/mu_b1/pii_scan_mu.py
+ba67bfb6b737afb71e7e252fee2acd561082f21e32095f7f0c52b18497a4ed0d  scrapers/mu_b1/pipeline_mu.sh
+99c7d5d6e37ede272bba826b066854de93ea0615f6e09248b64fb85eb2f1ed92  scrapers/mu_b1/readme_mu.py
+3b19512cd5e12799cf68d05e9f4a331b585399b7269a4c766308c21907da2c4c  scrapers/mu_b1/requirements.txt
+ae493dcc040f22127c8c9064679583fe8f49f620f1a1206968e230b36a1f9139  scrapers/mu_b1/robots_guard.py
+e6f32ad254a8f2528536cedcc9f5603687f7bd3d756c777ebf1bf94540c7ee2c  scrapers/mu_b1/split_mu.py
+154c41c53bd815b626a0019e68e020effa150395344cfe6928901f4498c7a1c8  scrapers/mu_b1/stage_mu.py
+96bfc34ee5b6fff94c089f19218d86d277f7ef63c86f7d841381d9c63306fe80  scrapers/mu_b1/validate_split_mu.py
+9bbbc728b75be42503eb079bc3cedf48b75af46a582a56637e8336760b462058  scrapers/mu_b1/verify_mu.py
+e6ecae506421274a004c99793bb214b76928e014f416cd6a71a3f583a866f1cc  scrapers/mu_b1/webmail_mu.py
+3b19512cd5e12799cf68d05e9f4a331b585399b7269a4c766308c21907da2c4c  scrapers/requirements.txt

data/articles.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:891500bb92ff65ab32be1db82481332dc1ca728052865b8eb29c8aa0637e48a2
-size 1833206
+oid sha256:e99b82992ad3cc6faac0e702fab5b44f75f58c1843f5d91fe4b2692f6de4e664
+size 8215798

data/laws.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:60271dcf6d4967d6ed1eab8108107f479e69627668dfa214c875f3ae076c198d
-size 1673306
+oid sha256:4045d9a063c367d264f20cdf0035e443787ddd82a20710cd6eed371f28ca9a1e
+size 7596440

manifests/mu_b1_code.json

@@ -0,0 +1,33 @@
+{
+ "bundle": "scrapers/mu_b1",
+ "files": {
+  "README.md": "e5b59be89063d70973109e5c0d1e40292aca55d33faf8e22cbf9eb4871255b60",
+  "articles_mu.py": "3666a01e0aacada4f37fd727cfbb0dd4401c1c7611788ed7ddfa87eb51afee40",
+  "br_waiting.sh": "d0b5bb288e11db24ff4b9ba10f9044bed52b2a836e6a33af30ca335cc5240779",
+  "challenge_detector_v2.py": "d1a2050ece0e8030fa06d1595ef149b17fccc290d998116c9368f33d8e67efe0",
+  "classify_mu.py": "2ef0a6427fb829855d4167d9ac10a1fa8676ddc72a834049bc0d9a929f165dfe",
+  "collect_mu.py": "ece509d861a2d71600ebda5af0ee19ab830aa8f8e0ebe2ce0ae3e7d942c68d39",
+  "extract_mu.py": "3cb0c44612fe290f13cc8154555c2afe065c3b8a36a091dee63b4d20104e8bb0",
+  "finalize_mu.py": "763513542d94c7cd4259b8b4120e692319305cbf6ed174176de112e433ee7e06",
+  "mu_net.py": "d855c2da5a06029077ec55c76bdf5930c62e1e2fc48a5d7911bb006cdf8c08f8",
+  "ocr_mu.py": "c6f4cad70e5d8a031f0fba2b3c610eb407084307f09e2727636cc4e8abd404a8",
+  "pii_scan_mu.py": "588e5f4888c0b3c7b8b16dbeb61ae6443d3983bb737fa0d857c2c14ab7d78667",
+  "pipeline_mu.sh": "ba67bfb6b737afb71e7e252fee2acd561082f21e32095f7f0c52b18497a4ed0d",
+  "readme_mu.py": "99c7d5d6e37ede272bba826b066854de93ea0615f6e09248b64fb85eb2f1ed92",
+  "requirements.txt": "3b19512cd5e12799cf68d05e9f4a331b585399b7269a4c766308c21907da2c4c",
+  "robots_guard.py": "ae493dcc040f22127c8c9064679583fe8f49f620f1a1206968e230b36a1f9139",
+  "split_mu.py": "e6f32ad254a8f2528536cedcc9f5603687f7bd3d756c777ebf1bf94540c7ee2c",
+  "stage_mu.py": "154c41c53bd815b626a0019e68e020effa150395344cfe6928901f4498c7a1c8",
+  "validate_split_mu.py": "96bfc34ee5b6fff94c089f19218d86d277f7ef63c86f7d841381d9c63306fe80",
+  "verify_mu.py": "9bbbc728b75be42503eb079bc3cedf48b75af46a582a56637e8336760b462058",
+  "webmail_mu.py": "e6ecae506421274a004c99793bb214b76928e014f416cd6a71a3f583a866f1cc"
+ },
+ "requirements": {
+  "scrapers/requirements.txt": "3b19512cd5e12799cf68d05e9f4a331b585399b7269a4c766308c21907da2c4c"
+ },
+ "robots_guard": {
+  "upstream_sha256": "fa8823164631f53174a67a4b100f5278758b151c3e6a522d8c9987bb57753542",
+  "bundled_sha256": "ae493dcc040f22127c8c9064679583fe8f49f620f1a1206968e230b36a1f9139",
+  "change": "cache root default changed from an absolute fleet path to the relative 'legal-corpora' (LEGAL_CORPORA_ROOT overrides); no logic change"
+ }
+}

manifests/mu_b1_drops.jsonl

@@ -0,0 +1,95 @@
+{"key": "7ba0ffcf4493224f", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/A/AFRICAN%20CULTURAL%20CENTRE%20TRUST%20FUND%20ACT.pdf", "title": "AFRICAN CULTURAL CENTRE TRUST FUND ACT", "reason": "empty_text"}
+{"key": "4e343704d62c7607", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/A/AGRICULTURAL%20DIVERSIFICATION%20CORPORATION%20ACT,%20No%2012%20of%201983.pdf", "title": "AGRICULTURAL DIVERSIFICATION CORPORATION ACT", "reason": "empty_text"}
+{"key": "f298a134a8f5cdc9", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/A/APPRENTICESHIPACT.pdf", "title": "APPRENTICESHIP ACT", "reason": "empty_text"}
+{"key": "4b0842c0424620fd", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/A/Ar/ARBITRATION(FOREIGNAWARDS)ACT.pdf", "title": "ARBITRATION (FOREIGN AWARDS) ACT", "reason": "empty_text"}
+{"key": "3fc9457766c00710", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/A/Ar/ARBITRATIONCLAUSES(PROTOCOL)ACT.pdf", "title": "ARBITRATION CLAUSES (PROTOCOL) ACT", "reason": "empty_text"}
+{"key": "6e01f49a2abfff0b", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/CAISSE%20CENTRALE%20DE%20COOP%c3%89RATION%20ECONOMIQUE%20%28IMMUNITIES%20AND%20PRIVILEGES%29%20ACT%2c%20No%2048%20of%201975.pdf", "title": "CAISSE CENTRALE DE COOPéRATION ECONOMIQUE (IMMUNITIES AND PRIVILEGES) ACT", "reason": "empty_text"}
+{"key": "ee6e986635912251", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/CARGO%20HANDLING%20CORPORATION%20ACT%2c%20No%2020%20of%201983.pdf", "title": "CARGO HANDLING CORPORATION ACT", "reason": "empty_text"}
+{"key": "821ddce71c3a683b", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/CENTRAL%20TENDER%20BOARD%20ACT,%20No%2032%20of%202000.pdf", "title": "CENTRAL TENDER BOARD ACT", "reason": "empty_text"}
+{"key": "c5b01f8fa912659d", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/CIVIL%20AVIATION%20%28FEES%20AND%20CHARGES%29%20ACT%2c%20No%2021%20of%201977.pdf", "title": "CIVIL AVIATION (FEES AND CHARGES) ACT", "reason": "empty_text"}
+{"key": "284c629a28f6fb30", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/CIVIL%20AVIATION%20%28TRANSFER%20OF%20UNDERTAKING%29%20ACT%2c%20No%2041%20of%201993.pdf", "title": "CIVIL AVIATION (TRANSFER OF UNDERTAKING) ACT", "reason": "empty_text"}
+{"key": "bbb933dcd686b141", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Co/COMMERCIAL%20AND%20INDUSTRIAL%20INVESTMENT%20TRUST%20OF%20MAURITIUS%20ACT%2c%20No%2034%20of%201976.pdf", "title": "COMMERCIAL AND INDUSTRIAL INVESTMENT TRUST OF MAURITIUS ACT", "reason": "empty_text"}
+{"key": "2174df15b3a7e76e", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/D/DISTRIBUTION%20OF%20FODDER%20(CONTROL)%20ACT,%20No%2010%20of%201961.pdf", "title": "DISTRIBUTION OF FODDER (CONTROL) ACT", "reason": "empty_text"}
+{"key": "a03ae02367ef8a71", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/D/DISTRICT%20COURTS%20EXECUTION%20ACT,%20No%2017%20of%201947.pdf", "title": "DISTRICT COURTS EXECUTION ACT", "reason": "empty_text"}
+{"key": "9655cdc4a5ee06a1", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/F/Fi/FINANCE%20AND%20AUDIT%20(TEMPORARY%20PROVISIONS)%20ACT,%20No%203%20of%202006.pdf", "title": "FINANCE AND AUDIT (TEMPORARY PROVISIONS) ACT", "reason": "empty_text"}
+{"key": "03a1ecef7cc6513a", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/F/FREEPORT%20(TRANSFER%20OF%20UNDERTAKING)%20ACT,%20No%2018%20of%202001.pdf", "title": "FREEPORT (TRANSFER OF UNDERTAKING) ACT", "reason": "empty_text"}
+{"key": "fff726f4434e17db", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/G/GAMING%20ACT,18%20of%201973.pdf", "title": "GAMING ACT", "reason": "empty_text"}
+{"key": "182181a39d77e729", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/G/GRANARY%20ACT,%20Cap%2064.pdf", "title": "GRANARY ACT", "reason": "empty_text"}
+{"key": "d8d7600b20a20cdc", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/H/HORSE%20RACING%20BOARD%20ACT,%20No%2023%20of%202003.pdf", "title": "HORSE RACING BOARD ACT", "reason": "empty_text"}
+{"key": "b9626e5523b1978d", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/I/IMPRISONMENT%20FOR%20CIVIL%20DEBT%20(ABOLITION)%20ACT,%20No%2027%20of%202006.pdf", "title": "IMPRISONMENT FOR CIVIL DEBT (ABOLITION) ACT", "reason": "empty_text"}
+{"key": "ee65f35c1942e26d", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/M/MCCB%20LIMITED%20(LIQUIDATION)%20ACT,%20No%208%20of%201996.pdf", "title": "MCCB LIMITED (LIQUIDATION) ACT", "reason": "empty_text"}
+{"key": "40fd62e97c3de316", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/N/Na/NATIONAL%20INDUSTRIES%20(REGISTRATION%20AND%20LICENSING)%20ACT,%20No%2057%20of%201968.pdf", "title": "NATIONAL INDUSTRIES (REGISTRATION AND LICENSING) ACT", "reason": "empty_text"}
+{"key": "405319e445b13f42", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/N/Na/NATIONAL%20UNIVERSITY%20OF%20MAURITIUS%20(PROVISIONAL%20COUNCIL)%20ACT,%20No%2023%20of%201982.pdf", "title": "NATIONAL UNIVERSITY OF MAURITIUS (PROVISIONAL COUNCIL) ACT", "reason": "empty_text"}
+{"key": "729dbc1d07cbf0c5", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pr/PRESIDENTIAL%20COMMISSION%20ACT%2c%20No%202%20of%201997.pdf", "title": "PRESIDENTIAL COMMISSION ACT", "reason": "empty_text"}
+{"key": "a22dbdd99c124733", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pr/PREVENTION%20OF%20MALARIA%20ACT%2c%20No%2028%20of%201946.pdf", "title": "PREVENTION OF MALARIA ACT", "reason": "empty_text"}
+{"key": "c29abf65d6b64f5e", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pr/PRIVATISATION%20FUND%20%28REVENUE%20AND%20EXPENDITURE%29%20ACT%2c%20No%2019%20of%201999.pdf", "title": "PRIVATISATION FUND (REVENUE AND EXPENDITURE) ACT (2)", "reason": "empty_text"}
+{"key": "40413e3675321f1e", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pr/PRIVATISATION%20FUND%20%28REVENUE%20AND%20EXPENDITURE%29%20ACT%2c%20No%2015%20of%201997.pdf", "title": "PRIVATISATION FUND (REVENUE AND EXPENDITURE) ACT", "reason": "empty_text"}
+{"key": "f7dc171ee2b2f3bc", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pr/PRIZE%20COMPETITIONS%20ACT%2c%20No.%2036%20of%201975.pdf", "title": "PRIZE COMPETITIONS ACT", "reason": "empty_text"}
+{"key": "6c664823836b3bce", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pu/PUBLIC%20SECURITY%20ACT%2c%20No.%201%20of%202000.pdf", "title": "PUBLIC SECURITY ACT", "reason": "empty_text"}
+{"key": "086c38e8b815bac3", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pu/PUBLIC%20TRUSTEE%20ACT%2c%20No.%2027%20of%201989.pdf", "title": "PUBLIC TRUSTEE ACT", "reason": "empty_text"}
+{"key": "a667e747d86f61b3", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/R/Re/REPLENISHMENT%20OF%20THE%20CONTINGENCIES%20FUND%20%282005-2006%29%20ACT%2c%20No%207%20of%202006.pdf", "title": "REPLENISHMENT OF THE CONTINGENCIES FUND (2005-2006) ACT", "reason": "empty_text"}
+{"key": "6654614ffd916608", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Si/SILVERCURRENCYPROTECTIONACTCap139.pdf", "title": "SILVER CURRENCY PROTECTION ACT", "reason": "empty_text"}
+{"key": "40e6d081c3f5c2b4", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Su/SUGARINDUSTRYDEVELOPMENTFUNDSREPEALACTNo18of1994.pdf", "title": "SUGAR INDUSTRY DEVELOPMENT FUNDS (REPEAL) ACT", "reason": "empty_text"}
+{"key": "3eafb4a58beb4ecf", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/T/Te/TELECOMMUNICATIONTRANSFERACTNo11of1988.pdf", "title": "TELECOMMUNICATION (TRANSFER) ACT", "reason": "empty_text"}
+{"key": "af1cffbe99defa83", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/U/Un/UNIONCATHOLIQUEDELILEMAURICEACTCap384.pdf", "title": "UNION CATHOLIQUE DE L’ILE MAURICE ACT", "reason": "empty_text"}
+{"key": "6560512b9d97e042", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/W/WAGESANDSALARIESAGGREGATIONOFCOSTOFLIVINGALLOWANCEACT24of1976.pdf", "title": "WAGES AND SALARIES (AGGREGATION OF COST OF LIVING ALLOWANCE) ACT", "reason": "empty_text"}
+{"key": "8c9740ba1e7abfc7", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/W/WIDOWSANDORPHANSPENSIONFUNDACTCap342.pdf", "title": "WIDOWS AND ORPHANS PENSION FUND ACT", "reason": "empty_text"}
+{"key": "0f98364c355d283b", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/A/ADVERTISEMENTS%20REGULATION%20ACT.pdf", "title": "ADVERTISEMENTS REGULATION ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/A/Advertisements%20Regulation%20Act%2c%20Cap.%20281.pdf"}
+{"key": "d243f4407ce4e5bc", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/B/BIOLOGICAL%20AND%20TOXIN%20WEAPONS%20CONVENTION%20ACT%2c%20No%202%20of%202004.pdf", "title": "BIOLOGICAL AND TOXIN WEAPONS CONVENTION ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/B/Biological%20and%20Toxin%20Weapons%20Convention%20Act%2c%20No.%202%20of%202004.pdf"}
+{"key": "c2fd0be65616335f", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/B/BUS%20INDUSTRY%20EMPLOYEES%20WELFARE%20FUND%20ACT%2c%20No%2036%20of%202002.pdf", "title": "BUS INDUSTRY EMPLOYEES WELFARE FUND ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/B/Bus%20Industry%20Employees%20Welfare%20Fund%20Act%2c%20No.%2036%20of%202002.pdf"}
+{"key": "4218e4497f9cca50", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/CADASTRAL%20SURVEY%20ACT%2c%20No%2022%20of%202011.pdf", "title": "CADASTRAL SURVEY ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Cadastral%20Survey%20Act%2c%20No.%2022%20of%202011.pdf"}
+{"key": "bda62140942ea081", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/CHEMICAL%20WEAPONS%20CONVENTION%20ACT%2c%20No%203%20of%202003.pdf", "title": "CHEMICAL WEAPONS CONVENTION ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Chemical%20Weapons%20Convention%20Act%2c%20No.%203%20of%202003.pdf"}
+{"key": "9e033e1401bd8d7f", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/CIVIL%20SERVICE%20FAMILY%20PROTECTION%20SCHEME%20ACT%2c%20No%2016%20of%201969.pdf", "title": "CIVIL SERVICE FAMILY PROTECTION SCHEME ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Civil%20Service%20Family%20Protection%20Scheme%20Act%2c%20No.%2016%20of%201969.pdf"}
+{"key": "791518a01e082ecc", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/CIVIL%20STATUS%20ACT%2c%20No%2023%20of%201981.pdf", "title": "CIVIL STATUS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Civil%20Status%20Act%2c%20No.%2023%20of%201981.pdf"}
+{"key": "30d95c51bc31e6bf", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/CLINICAL%20TRIALS%20ACT%2c%20No%208%20of%202011.pdf", "title": "CLINICAL TRIALS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Clinical%20Trials%20Act%2c%20No.%208%20of%202011.pdf"}
+{"key": "b4974e4c1c9d3bb7", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Co/COMMUNITY%20SERVICE%20ORDER%20ACT%2c%20No%2017%20of%202002.pdf", "title": "COMMUNITY SERVICE ORDER ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Community%20Service%20Order%20Act%2c%20No.%2017%20of%202002.pdf"}
+{"key": "5c18ef673bb22abd", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Co/CompaniesActNo.15of2001.pdf", "title": "COMPANIES ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Companies%20Act%2c%20No.%2015%20of%202001.pdf"}
+{"key": "1aeda15202b55ca4", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Co/ContructionIndustryDevelopmentBoardActNo35of2008.pdf", "title": "CONSTRUCTION INDUSTRY DEVELOPMENT BOARD ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Construction%20Industry%20Development%20Board%20Act%2c%20No.%2035%20of%202008.pdf"}
+{"key": "6f5af47050fd9f1d", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Co/CONSUMER%20PROTECTION%20%28PRICE%20AND%20SUPPLIES%20CONTROL%29%20ACT%2c%20No%2012%20of%201998.pdf", "title": "CONSUMER PROTECTION (PRICE AND SUPPLIES CONTROL) ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Consumer%20Protection%20%28Price%20and%20Supplies%20Control%29%20Act%2c%20No.%2012%20of%201998.pdf"}
+{"key": "6025945353a7fac1", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Co/CONVENTION%20FOR%20THE%20SUPPRESSION%20OF%20THE%20FINANCING%20OF%20TERRORISM%20ACT%2c%20No%2037%20of%202003.pdf", "title": "CONVENTION FOR THE SUPPRESSION OF THE FINANCING OF TERRORISM ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Convention%20for%20the%20Suppression%20of%20the%20Financing%20of%20Terrorism%20Act%2c%20No.%2037%20of%202003.pdf"}
+{"key": "9ba6c48db8ee1b7a", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Co/Co-operatives%20Act-Issue9.pdf", "title": "CO-OPERATIVES ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Co-operatives%20Act%2c%20No.%2022%20of%202016.pdf"}
+{"key": "a82ea8d0ce8d77e2", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/PATENTS%2c%20INDUSTRIAL%20DESIGNS%20AND%20TRADEMARKS%20ACT%2c%20NO%2025%20of%202002.pdf", "title": "PATENTS, INDUSTRIAL DESIGNS AND TRADEMARKS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Patents%2c%20Industrial%20Designs%20and%20Trademarks%20Act%2c%20No.%2025%20of%202002.pdf"}
+{"key": "0a7cedeed50c9254", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/PENSIONS%20ACT%2c%20No%2090%20of%201951%2c%2019%20of%201954%2c%205%20of%201976.pdf", "title": "PENSIONS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pensions%20Act%2c%20No.%2090%20of%201951%2c%2019%20of%201954%2c%205%20of%201976.pdf"}
+{"key": "733db42598b29b8e", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/PHARMACY%20ACT.pdf", "title": "PHARMACY ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pharmacy%20Act%2c%20No.%2060%20of%201983.pdf"}
+{"key": "a215ad6b308eee2a", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Planning%20and%20Development%20Act-I9.pdf", "title": "PLANNING AND DEVELOPMENT ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Planning%20and%20Development%20Act%2c%20No.%2032%20of%202004.pdf"}
+{"key": "f7d57066aca4967f", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/PORTS%20ACT%2c%20No%203%20of%201998.pdf", "title": "PORTS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Ports%20Act%2c%20No.%203%20of%201998.pdf"}
+{"key": "708d7730af93ee1e", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/POUCE%20STREAM%20%28AUTHORISED%20CONSTRUCTION%29%20ACT%2c%20No%2032%20of%201992.pdf", "title": "POUCE STREAM (AUTHORISED CONSTRUCTION) ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pouce%20Stream%20%28Authorised%20Construction%29%20Act%2c%20No.%2032%20of%201992.pdf"}
+{"key": "e1714f184160f78d", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pr/PREVENTION%20OF%20CORRUPTION%20ACT%2c%20NO%205%20of%202002.pdf", "title": "PREVENTION OF CORRUPTION ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Prevention%20of%20Corruption%20Act%2c%20No.%205%20of%202002.pdf"}
+{"key": "9425fff219a5e71d", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pr/PreventionofTerrorismAct-I9.pdf", "title": "PREVENTION OF TERRORISM ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Prevention%20of%20Terrorism%20Act%2c%20No.%202%20of%202002.pdf"}
+{"key": "c92b1fcf3cc89d2d", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pr/PRIVATE%20PENSION%20SCHEMES%20ACT%2c%2015%20of%202012.pdf", "title": "PRIVATE PENSION SCHEMES ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Private%20Pension%20Schemes%20Act%2c%20No.%2015%20of%202012.pdf"}
+{"key": "9e519ca8c84537ef", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pr/ProfessionalLandSurveyorsCouncilAct-I9.pdf", "title": "PROFESSIONAL LAND SURVEYORS’ COUNCIL ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Professional%20Land%20Surveyors%e2%80%99%20Council%20Act%2c%20No.%204%20of%202014.pdf"}
+{"key": "c43ab1f0dffc9253", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pr/PROTECTED%20CELL%20COMPANIES%20ACT%2c%20No.%2037%20of%201999.pdf", "title": "PROTECTED CELL COMPANIES ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Protected%20Cell%20Companies%20Act%2c%20No.%2037%20of%201999.pdf"}
+{"key": "8156f1c219ad7640", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pr/PROTECTION%20OF%20HUMAN%20RIGHTS%20ACT%2c%20No.%2019%20of%201998.pdf", "title": "PROTECTION OF HUMAN RIGHTS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Protection%20of%20Human%20Rights%20Act%2c%20No.%2019%20of%201998.pdf"}
+{"key": "2e39e544a90600e6", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pu/PubicDebtManagementAct-I9.pdf", "title": "PUBLIC DEBT MANAGEMENT ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Public%20Debt%20Management%20Act%2c%20No.%205%20of%202008.pdf"}
+{"key": "b96c6bdf654e643b", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pu/PublicProcurementAct-I9.pdf", "title": "PUBLIC PROCUREMENT ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Public%20Procurement%20Act%2c%20No.%2033%20of%202006.pdf"}
+{"key": "97bd552d14a55b15", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/R/Re/RECOVERY%20OF%20STATE%20DEBTS%20ACT%2c%20Cap%20137.pdf", "title": "RECOVERY OF STATE DEBTS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/R/Re/Recovery%20of%20State%20Debts%20Act%2c%20Cap.%20137.pdf"}
+{"key": "f1146d62c347e574", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/R/Re/REGISTRAR-GENERAL%20ACT%2c%20Cap%20340.pdf", "title": "REGISTRAR-GENERAL ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/R/Re/Registrar-General%20Act%2c%20Cap.%20340.pdf"}
+{"key": "e3a43edd98e38bdb", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/R/Re/Registration%20of%20Associations%20Act-I9.pdf", "title": "REGISTRATION OF ASSOCIATIONS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/R/Re/Registration%20of%20Associations%20Act%2c%20No.%2035%20of%201978.pdf"}
+{"key": "04245d19f87d727d", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Sa/SaleofImmovablePropertyActCap202.pdf", "title": "SALE OF IMMOVABLE PROPERTY ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Sa/Sale%20of%20Immovable%20Property%20Act%2c%20Cap.%20202.pdf"}
+{"key": "4f14b761caf74621", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Se/SECURITIESCENTRALDEPOSITORYCLEARINGANDSETTLEMENTACTNo30of1996.pdf", "title": "SECURITIES (CENTRAL DEPOSITORY, CLEARING AND SETTLEMENT) ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Se/Securities%20%28Central%20Depository%2c%20Clearing%20and%20Settlement%29%20Act%2c%20No.%2030%20of%201996.pdf"}
+{"key": "fbd029c7796f7670", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Se/Securities%20ActNo22of2005.pdf", "title": "SECURITIES ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Se/Securities%20Act%2c%20No.%2022%20of%202005.pdf"}
+{"key": "c8749ee20c117cc1", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Se/SEEDSACTNo10of2013.pdf", "title": "SEEDS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Se/Seeds%20Act%2c%20No.%2010%20of%202013.pdf"}
+{"key": "415d171cfbe0fb54", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/So/SocialAidActI9.pdf", "title": "SOCIAL AID ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/So/Social%20Aid%20Act%2c%20No.%202%20of%201983.pdf"}
+{"key": "8b344b86a568c3b8", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/SportsActI9.pdf", "title": "SPORTS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Sports%20Act%2c%20No.%2035%20of%202016.pdf"}
+{"key": "c680a70c690e1ffe", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/St/STAMPDUTYACTNo37of1990.pdf", "title": "STAMP DUTY ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/St/Stamp%20Duty%20Act%2c%20No.%2037%20of%201990.pdf"}
+{"key": "7bbbeb4490e0223e", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/St/StateLandsActI9.pdf", "title": "STATE LANDS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/St/State%20Lands%20Act%2c%20Cap.%20224.pdf"}
+{"key": "1b4ffe08c7aa1232", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/St/StateTradingCorporationActI9.pdf", "title": "STATE TRADING CORPORATION ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/St/State%20Trading%20Corporation%20Act%2c%20No.%2024%20of%201982.pdf"}
+{"key": "d7410ba50c1ddf6c", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/St/STATISTICSACTNo38of2000.pdf", "title": "STATISTICS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/St/Statistics%20Act%2c%20No.%2038%20of%202000.pdf"}
+{"key": "1e15f5acab1be0e1", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/St/StatutoryBodiesAccountsandAuditActI9.pdf", "title": "STATUTORY BODIES (ACCOUNTS AND AUDIT) ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/St/Statutory%20Bodies%20%28Accounts%20and%20Audit%29%20Act%2c%20No.%202%20of%201972.pdf"}
+{"key": "bdab20ac1e44d8d5", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Su/SugarIndustryEfficiencyActI9.pdf", "title": "SUGAR INDUSTRY EFFICIENCY ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Su/Sugar%20Industry%20Efficiency%20Act%2c%20No.%2020%20of%202001.pdf"}
+{"key": "f7299c8a87288e13", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Su/SugarInsuranceFundActI9.pdf", "title": "SUGAR INSURANCE FUND ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/S/Su/Sugar%20Insurance%20Fund%20Act%2c%20No.%204%20of%201974.pdf"}
+{"key": "9520bccb1e5dd83c", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/T/TOWNANDCOUNTRYPLANNINGACTNo6of1954.pdf", "title": "TOWN AND COUNTRY PLANNING ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/T/Town%20and%20Country%20Planning%20Act%2c%20No.%206%20of%201954.pdf"}
+{"key": "0c420dab59539e0b", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/T/Tr/TranscriptionandMortgageActI9.pdf", "title": "TRANSCRIPTION AND MORTGAGE ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/T/Transcription%20and%20Mortgage%20Act%2c%20Cap.%20417.pdf"}
+{"key": "b0a30ac1be59035d", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/U/Un/UNIVERSIT%c3%89DESMASCAREIGNESACTNo4of2012.pdf", "title": "UNIVERSITÉ DES MASCAREIGNES ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/U/Universite%20Des%20Mascareignes%20Act%2c%20No.%204%20of%202012.pdf"}
+{"key": "5e0dff6a7e206d4b", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/U/Un/UNIVERSITYOFTECHNOLOGYMAURITIUSACTNo2of2000.pdf", "title": "UNIVERSITY OF TECHNOLOGY, MAURITIUS ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/U/University%20of%20Technology%2c%20Mauritius%20Act%2c%20No.%202%20of%202000.pdf"}
+{"key": "c58d8dbe0b8b9ae0", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/V/ValueAddedTaxActI9.pdf", "title": "VALUE ADDED TAX ACT", "reason": "duplicate_act_in_batch", "kept_url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/V/Value%20Added%20Tax%20Act%2c%20No.%202%20of%201998.pdf"}
+{"key": "f28b6f88f200be90", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/A/Acquisitive%20Prescription%20Act%2c%20No.%2013%20of%202018.pdf", "title": "ACQUISITIVE PRESCRIPTION ACT, NO. 13 of 2018", "reason": "duplicate_of_tip", "tip_id": "mu-cc-f1cdbab51145f4"}
+{"key": "b4083d401aab3291", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/A/APPROPRIATIONACT.pdf", "title": "APPROPRIATION ACT", "reason": "duplicate_of_tip", "tip_id": "mu-cc-2c2bee3bfe9bf2"}
+{"key": "b7d149af2256fa4e", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Chemical%20Weapons%20Convention%20Act%2c%20No.%203%20of%202003.pdf", "title": "CHEMICAL WEAPONS CONVENTION ACT, NO 3 OF 2003", "reason": "duplicate_of_tip", "tip_id": "mu-cc-1e9016b31876e1"}
+{"key": "894fd81935047ab8", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/C/Co/COMBATING%20OF%20TRAFFICKING%20IN%20PERSONS%20ACT.pdf", "title": "COMBATING OF TRAFFICKING IN PERSONS ACT", "reason": "duplicate_of_tip", "tip_id": "mu-cc-7e3f590586f3e9"}
+{"key": "1f9e0d95b59228b9", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/I/Immigration%20Act-I9.pdf", "title": "IMMIGRATION ACT", "reason": "duplicate_of_tip", "tip_id": "mu-cc-7ab575069176d2"}
+{"key": "8803edf731ddb37f", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/M/MUTUAL%20ASSISTANCE%20IN%20CRIMINAL%20AND%20RELATED%20MATTERS%20ACT,%20No%2035%20of%202003.pdf", "title": "MUTUAL ASSISTANCE IN CRIMINAL AND RELATED MATTERS ACT", "reason": "duplicate_of_tip", "tip_id": "mu-cc-fb48478a44a181"}
+{"key": "b19330567869eab3", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/O/OFFICIAL%20SECRETS%20ACT,%20No%2013%20of%201972.pdf", "title": "OFFICIAL SECRETS ACT", "reason": "duplicate_of_tip", "tip_id": "mu-cc-e451de3316f33c"}
+{"key": "88ad8c36b0d31567", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Public%20Debt%20Management%20Act%2c%20No.%205%20of%202008.pdf", "title": "PUBLIC DEBT MANAGEMENT ACT, NO 5 OF 2008", "reason": "duplicate_of_tip", "tip_id": "mu-cc-2b68bfa6dd3db2"}
+{"key": "1feff0839a16f7bf", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Pu/PublicOfficersProtectionAct-I9.pdf", "title": "PUBLIC OFFICERS’ PROTECTION ACT", "reason": "duplicate_of_tip", "tip_id": "mu-cc-d0c62feb8faaa7"}
+{"key": "cbbd7cff752a0b89", "url": "https://attorneygeneral.govmu.org/Documents/Laws%20of%20Mauritius/A-Z%20Acts/P/Public%20Procurement%20Act%2c%20No.%2033%20of%202006.pdf", "title": "PUBLIC PROCUREMENT ACT, NO 33 OF 2006", "reason": "duplicate_of_tip", "tip_id": "mu-cc-699b9cfdc66abf"}

manifests/mu_b1_pii_scan.json

@@ -0,0 +1,4 @@
+{
+ "new_fail": 0,
+ "new_hits": []
+}

manifests/mu_b1_summary.json

@@ -0,0 +1,287 @@
+{
+ "batch": "mu_b1",
+ "repo": "endomorphosis/ipfs_mauritius_laws",
+ "mode": "append",
+ "parent": "80f8c63175886c85a94669f825086cee6c322009",
+ "tip_files": [
+  ".gitattributes",
+  "MANIFEST.md",
+  "README.md",
+  "data/articles.parquet",
+  "data/laws.parquet",
+  "scrapers/archive_fallbacks.py",
+  "scrapers/collect_mu.py",
+  "scrapers/common.py",
+  "scrapers/pdf_extract_lib.py",
+  "scrapers/world_lib.py"
+ ],
+ "tip_laws": 197,
+ "tip_articles": 5934,
+ "new_laws": 526,
+ "new_articles": 16881,
+ "laws_rows": 723,
+ "articles_rows": 22815,
+ "languages": {
+  "en": 519,
+  "fr": 7
+ },
+ "drops": {
+  "empty_text": 36,
+  "duplicate_act_in_batch": 49,
+  "duplicate_of_tip": 10
+ },
+ "whole_text_fallback": 36,
+ "degraded": [],
+ "ocr_used": [
+  {
+   "id": "mu-ago-act-31-1995-abolition-of-death-penalty-act",
+   "title": "ABOLITION OF DEATH PENALTY ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.15,
+   "sections": 3,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-7-1981-bonds-act",
+   "title": "BONDS ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 95.48,
+   "sections": 3,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-26-1981-convention-on-social-security-act",
+   "title": "CONVENTION ON SOCIAL SECURITY ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 93.59,
+   "sections": 4,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-cap-171-deposit-of-powers-of-attorney-act",
+   "title": "DEPOSIT OF POWERS OF ATTORNEY ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 95.69,
+   "sections": 4,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-cap-35-gazette-charges-act",
+   "title": "GAZETTE (CHARGES) ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.19,
+   "sections": 3,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-cap-36-gazette-privilege-act",
+   "title": "GAZETTE (PRIVILEGE) ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 92.41,
+   "sections": 3,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-cap-356-government-teachers-benevolent-fund-act",
+   "title": "GOVERNMENT TEACHERS’ BENEVOLENT FUND ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.65,
+   "sections": 2,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-1-1980-hotel-and-catering-training-school-levy-of-fees-act",
+   "title": "HOTEL AND CATERING TRAINING SCHOOL (LEVY OF FEES) ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 93.16,
+   "sections": 3,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-47-1973-judicial-and-legal-service-commission-and-disciplined-forces-service-c",
+   "title": "JUDICIAL AND LEGAL SERVICE COMMISSION AND DISCIPLINED FORCES SERVICE COMMISSION (ALLOWANCES) ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 95.13,
+   "sections": 2,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-31-2008-offices-of-minister-act",
+   "title": "OFFICES OF MINISTER ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.66,
+   "sections": 2,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-cap-407-pawnbrokers-act",
+   "title": "PAWNBROKERS ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 95.03,
+   "sections": 1,
+   "whole": true,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-25-2016-police-membership-of-trade-union-act",
+   "title": "POLICE (MEMBERSHIP OF TRADE UNION) ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 93.33,
+   "sections": 3,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-41-1969-prescription-of-landed-property-act",
+   "title": "PRESCRIPTION OF LANDED PROPERTY ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.57,
+   "sections": 2,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-3-2002-prevention-of-terrorism-denial-of-bail-act",
+   "title": "PREVENTION OF TERRORISM (DENIAL OF BAIL) ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 93.86,
+   "sections": 4,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-cap-377-prison-and-correctional-youth-centre-officers-benefit-fund-act",
+   "title": "PRISON AND CORRECTIONAL YOUTH CENTRE OFFICERS’ BENEFIT FUND ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 92.45,
+   "sections": 3,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-39-1948-public-officers-fees-act",
+   "title": "PUBLIC OFFICERS’ FEES ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.08,
+   "sections": 2,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-cap-340-registrar-general-act-cap-340",
+   "title": "REGISTRAR-GENERAL ACT, CAP. 340",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.7,
+   "sections": 2,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-49-1973-reprint-of-laws-act",
+   "title": "REPRINT OF LAWS ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.28,
+   "sections": 6,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-cap-219-safety-of-dockers-act",
+   "title": "SAFETY OF DOCKERS ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.42,
+   "sections": 3,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-23-1975-students-relief-fund-act",
+   "title": "STUDENTS’ RELIEF FUND ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.51,
+   "sections": 6,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-63-1973-sugar-brokerage-tax-act",
+   "title": "SUGAR BROKERAGE TAX ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.64,
+   "sections": 2,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-supplementary-appropriation-act",
+   "title": "SUPPLEMENTARY APPROPRIATION ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 92.42,
+   "sections": 1,
+   "whole": true,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-4-1962-technical-co-operation-agreements-immunities-and-privileges-act",
+   "title": "TECHNICAL CO-OPERATION AGREEMENTS (IMMUNITIES AND PRIVILEGES) ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.76,
+   "sections": 2,
+   "whole": false,
+   "status": "ok"
+  },
+  {
+   "id": "mu-ago-act-16-1968-united-nations-act",
+   "title": "UNITED NATIONS ACT",
+   "text_source": "ocr",
+   "garble": 0.0,
+   "mean_conf": 94.91,
+   "sections": 3,
+   "whole": false,
+   "status": "ok"
+  }
+ ],
+ "codec": "ZSTD",
+ "row_groups": 1,
+ "heading_only_dropped": 1036,
+ "repealed_placeholders": 455,
+ "schedules": 379,
+ "number_mismatches": 10,
+ "webmail_redactions": 0,
+ "license_paraphrase": "Consolidated Acts of Mauritius as published by the Attorney General's Office (attorneygeneral.govmu.org). Described, not quoted: the site's Term of Use lets people make personal copies and printouts of the legislation under the Copyright Act, but publishing, disseminating or incorporating it for commercial use needs the prior approval of the Solicitor General; the site also says that only the LexisNexis 2016 Revised Laws of Mauritius (with their supplements) are the authoritative text, so these copies are for information only. Terms: https://attorneygeneral.govmu.org/Pages/Laws%20of%20Mauritius/Constitution/termofuse.aspx . Not legal advice.",
+ "terms_url": "https://attorneygeneral.govmu.org/Pages/Laws%20of%20Mauritius/Constitution/termofuse.aspx",
+ "staged_at": "2026-10-25T02:41:58Z"
+}

manifests/pii_scan_notes.md

@@ -0,0 +1,10 @@
+# PII scan notes (batch mu_b1)
+
+- Scope: every string column of the 526 new law rows and 16881 new article rows.
+- FAIL hits in new rows: 0.
+- WARN hits: {}.
+
+WARN hits are telephone/fax numbers printed in the Acts themselves (office numbers of public bodies, forms) or P.O. Box addresses of institutions; they are official texts and are kept. Values are not reproduced here.
+
+Rows with WARN hits:
+

manifests/webmail_redactions.json

@@ -0,0 +1,6 @@
+{
+ "placeholder": "[redacted-webmail]",
+ "total": 0,
+ "laws": [],
+ "note": "free-webmail addresses (standard, typo-domain, truncated, spaced, line-split) redacted in laws.text before splitting, so article slices inherit it; offsets refer to the stored text; no values recorded"
+}

scrapers/mu_b1/README.md

@@ -0,0 +1,58 @@
+# scrapers/mu_b1 — Mauritius AGO consolidated Acts, batch mu_b1 (ipfs_mauritius_laws)
+
+Self-contained bundle that produced the mu_b1 append to the Hugging Face dataset
+`endomorphosis/ipfs_mauritius_laws`. Nothing here imports from outside this directory
+(the earlier tip scrapers in `scrapers/*.py` are left untouched and are not needed).
+
+## Source
+- Official only: Attorney General's Office, Republic of Mauritius,
+  https://attorneygeneral.govmu.org/ — "Laws of Mauritius" A–Z consolidated Acts
+  (index page plus one sub-page per letter group; PDFs under /Documents/Laws of Mauritius/).
+- Terms of use: https://attorneygeneral.govmu.org/Pages/Laws%20of%20Mauritius/Constitution/termofuse.aspx
+  (see the dataset README for our paraphrase; the site notes that the authoritative
+  printed version is the LexisNexis-published edition, so this text is unofficial).
+- No archives (no Wayback / Common Crawl / archive.is), no logins, forms or challenge bypass.
+
+## Files
+| file | role |
+|---|---|
+| pipeline_mu.sh | orchestrator: gates, slot, catalog, fetch, extract, OCR, stage, verify |
+| collect_mu.py | catalog + PDF fetch (one request in flight, pacing max(8 s, Crawl-Delay)) |
+| mu_net.py | HTTP layer: robots_guard on every hop/redirect, challenge detection, requests.jsonl |
+| robots_guard.py | shared fleet robots guard (see "Changed sha" below) |
+| challenge_detector_v2.py | shared challenge/captcha detector |
+| br_waiting.sh | shared fleet helper: yields when the Americas BR lane is waiting |
+| extract_mu.py | pdftotext -layout per page; flags PDFs without a text layer |
+| ocr_mu.py | tesseract (system tessdata, self-test) only for PDFs without a text layer |
+| split_mu.py, classify_mu.py, articles_mu.py | section splitter, repeal-placeholder tagging, verbatim slices |
+| validate_split_mu.py | split check on the first 10 PDFs before the full fetch |
+| webmail_mu.py, pii_scan_mu.py | free-webmail redaction and PII scan |
+| stage_mu.py, readme_mu.py, finalize_mu.py | dedupe against the Hub tip, build parquet + README/MANIFEST/manifests |
+| verify_mu.py | all checks (substring gate, bounds, schema parity, secret scans, YAML, SHA256SUMS) |
+| requirements.txt | pinned Python dependencies |
+
+## How to run
+```bash
+pip install -r requirements.txt          # plus poppler-utils, tesseract-ocr (eng), ripgrep
+export MU_WORK=$PWD/work                 # all caches, logs and the pack go here
+bash pipeline_mu.sh                      # resumable; re-run after any stop
+tail -f "$MU_WORK/status.txt"            # PIPELINE_DONE / HARD_STOP / PARKED / *_FAIL
+```
+Environment variables:
+- `MU_WORK` – work directory (default `.`); `MU_SHM` – lock dir (default /dev/shm).
+- `BRW_BR_LOGS`, `BRW_LOCKS` – read by br_waiting.sh to locate the BR lane logs/locks
+  (if absent the helper reports "not waiting").
+- `LEGAL_CORPORA_ROOT` – set by mu_net.py to `$MU_WORK/legal-corpora` for robots caches.
+
+Outputs: `$MU_WORK/cache/*.pdf` (raw PDFs, kept), `requests.jsonl` (every request),
+`texts.jsonl`, and the pack in `$MU_WORK/hf_mu_b1/ipfs_mauritius_laws/`. The pipeline never uploads.
+
+## Stop rules
+403, 429, 503, a challenge/captcha (including on robots.txt) or a certificate-verification error
+stops the lane at once. A transport SSLError/connection reset gets one retry after 120 s;
+a second consecutive failure or 3 transport errors in total stops the run.
+
+## Changed sha
+`robots_guard.py` differs from the fleet original (sha256 fa8823164631f53174a67a4b100f5278758b151c3e6a522d8c9987bb57753542)
+only in its default ROOT ("legal-corpora", relative, instead of an absolute fleet path).
+The bundled sha256 of every file is recorded in `manifests/mu_b1_code.json` and `SHA256SUMS`.

scrapers/mu_b1/articles_mu.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""Article rows for one MU consolidated Act (batch mu_b1), with the verbatim-slice gate.
+* Sections come from split_mu.split_offsets(): each article text is law_text[start:end], a raw verbatim slice of the STORED law
+  text (no reflow); offsets ascending, non-overlapping, kept in metadata_json (char_start / char_end).
+* Schedules: a stand-alone capitals line '[FIRST ...] SCHEDULE' inside a section ends that section; the schedule becomes its own
+  article (-sch / -schN, title 'Schedule'), still a raw slice.
+* classify_mu: heading-only rows (arrangement-of-sections entries with no body) are DROPPED and returned for known_gaps; repeal
+  placeholders ('Repealed by ...', 'Omitted', MU 'N. —' dashes) are kept with metadata_json.body_status = 'repealed_placeholder'.
+* Dominant-article gate: a law with >= 5 articles where one article holds > 60 % of the article characters is demoted to one
+  whole-text article (reason dominant_article, listed in known_gaps).
+* Whole-text fallback (no numbered sections): one article = law_text.strip() (also a raw slice).
+* Ids: <law id>-s<n> / -sp<part>-<n>, assigned over ALL detected sections before dropping; clashes -> -dupN.
+gate(law_text, arts) returns the list of substring / order violations (must be empty)."""
+import json, os, re, sys
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import split_mu as S, classify_mu as C
+SCH = re.compile(r"(?m)^[ \t]*(?:(?:FIRST|SECOND|THIRD|FOURTH|FIFTH|SIXTH|SEVENTH|EIGHTH|NINTH|TENTH|ELEVENTH|TWELFTH)\s+)?SCHEDULE(?:\s+[IVXLC\d]+)?[ \t]*$")
+NUMH = re.compile(r"^\s*\d{1,3}[A-Z]{0,2}\.\s+")
+def _heading(sec_text, prev_head):
+    first = NUMH.sub("", sec_text.split("\n", 1)[0]).strip()
+    if first and len(first) <= 80 and not re.search(r"[.;:,—–-]\s*$", first) and first[:1].isupper() and "\n" in sec_text: return first
+    return prev_head
+def _cut_schedules(text, secs):
+    out = []
+    for s in secs:
+        body = text[s["start"]:s["end"]]
+        m = None
+        for mm in SCH.finditer(body):
+            if mm.start() > 0: m = mm; break
+        if not m: out.append(s); continue
+        cut = s["start"] + m.start() + (len(m.group(0)) - len(m.group(0).lstrip()))
+        en1 = cut
+        while en1 > s["start"] and text[en1 - 1].isspace(): en1 -= 1
+        a = dict(s, end=en1, text=text[s["start"]:en1])
+        b = {"num": "sch", "part": s["part"], "part_title": s["part_title"], "heading": "Schedule", "start": cut, "end": s["end"],
+             "text": text[cut:s["end"]], "schedule": True}
+        out += [a, b]
+    return out
+def build(lid, text, offid, src_url, jur=None, batch="mu_b1"):
+    secs = S.split_offsets(text) if text else []
+    secs = _cut_schedules(text, secs) if secs else []
+    for s in secs:
+        if s.get("schedule"): s["body_status"] = "body"
+    nonsch = [s for s in secs if not s.get("schedule")]
+    C.classify(nonsch)
+    whole_reason = None if secs else "no_numbered_sections"
+    if secs:
+        kept = [s for s in secs if s["body_status"] != "heading_only"]
+        tot = sum(s["end"] - s["start"] for s in kept) or 1
+        if len(kept) >= 5 and max(s["end"] - s["start"] for s in kept) > 0.6 * tot: whole_reason = "dominant_article"
+        if not kept: whole_reason = "only_heading_rows"
+    whole = whole_reason is not None
+    if whole:
+        st = len(text) - len(text.lstrip()); en = len(text.rstrip())
+        secs = [{"num": "1", "part": 1, "part_title": "", "heading": "", "start": st, "end": en, "text": text[st:en], "body_status": "body"}]
+    arts, dropped, aids, prev_head = [], [], set(), ""
+    for s in secs:
+        n = s["num"] if s["part"] == 1 else f"p{s['part']}-{s['num']}"
+        aid = f"{lid}-s{n}" if n != "sch" and not n.endswith("-sch") else f"{lid}-{n.replace('-sch', '-sch') if s['part'] > 1 else 'sch'}"
+        base, k = aid, 1
+        while aid in aids: k += 1; aid = f"{base}-dup{k}" if not s.get("schedule") else f"{base}{k}"
+        aids.add(aid)
+        if s["body_status"] == "heading_only":
+            dropped.append({"law_id": lid, "article_id": aid, "article_number": n, "part": s["part"], "char_start": s["start"], "char_end": s["end"],
+                            "reason": "heading_only_toc_entry", "heading_text": s["text"][:200]}); continue
+        if whole: label, head = "Whole text", ""
+        elif s.get("schedule"): label, head = "Schedule", "Schedule"
+        else:
+            head = _heading(s["text"], s.get("heading", "")) if not whole else ""
+            label = f"Section {s['num']}" + (f" ({head})" if head else "")
+        if s["part"] > 1 and s["part_title"] and not whole: label = f"{s['part_title']} — {label}"
+        md = {"batch": batch, "law_identifier": lid, "part": s["part"], "part_title": s["part_title"], "heading": head,
+              "whole_text_fallback": whole, "whole_text_reason": whole_reason, "char_start": s["start"], "char_end": s["end"],
+              "body_status": s["body_status"], "schedule": bool(s.get("schedule"))}
+        arts.append({"law_id": lid, "id": aid, "title": label, "text": text[s["start"]:s["end"]], "source_url": src_url,
+                     "document_number": offid, "article_number": n, "record_type": "article",
+                     "metadata_json": json.dumps(md, ensure_ascii=False)})
+    return arts, dropped, whole_reason
+def gate(text, arts):
+    bad, last = [], -1
+    for a in arts:
+        md = json.loads(a["metadata_json"]); st, en = md.get("char_start"), md.get("char_end")
+        if st is None or text[st:en] != a["text"]: bad.append({"id": a["id"], "why": "slice_mismatch"}); continue
+        if a["text"] not in text: bad.append({"id": a["id"], "why": "not_substring"}); continue
+        if st < last: bad.append({"id": a["id"], "why": "offsets_not_ascending"})
+        last = en
+    return bad
+def dominant(arts):
+    if len(arts) < 5: return False
+    L = [len(a["text"]) for a in arts]; return max(L) > 0.6 * (sum(L) or 1)

scrapers/mu_b1/br_waiting.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# Exit 0 if an Americas BR job is alive and WAITING for a runner slot (we must yield), 1 otherwise. Read-only.
+# BR job = the BR runner pid in americas/br/logs/b*_runner.pid, or any process running collect_br_sigpub / an americas
+# requeue / run_slot_job / run_br* script (br_stage_chain.py only stages/prunes and takes no slot -> ignored).
+# Waiting = alive and it is neither a slot-lock holder nor an ancestor of one (a BR wrapper whose child holds a slot runs).
+BRL=${BRW_BR_LOGS:-}  # fleet-local dir holding Americas BR b*_runner.pid files; unset = check processes only
+LOCKS=${BRW_LOCKS:-/dev/shm/muni_runner.lock /dev/shm/muni_runner.slot2.lock /dev/shm/muni_runner.slot3.lock}
+cand=""
+for f in ${BRL:+$BRL/b*_runner.pid}; do
+  [ -f "$f" ] || continue; p=$(tr -dc 0-9 < "$f"); [ -n "$p" ] && kill -0 "$p" 2>/dev/null && cand="$cand $p"
+done
+cand="$cand $(pgrep -f 'collect_br_sigpub|americas/[^ ]*(requeue|run_slot_job|run_br)|run_br_|br_pack4' 2>/dev/null | tr '\n' ' ')"
+pids=""
+for p in $cand; do
+  [ "$p" = "$$" ] && continue
+  c=$(tr '\0' ' ' < /proc/$p/cmdline 2>/dev/null) || continue
+  case "$c" in *br_stage_chain*|*br_waiting*|*pgrep*) continue;; esac
+  pids="$pids $p"
+done
+[ -z "$pids" ] && exit 1
+fam=" "
+for h in $(fuser $LOCKS 2>/dev/null); do
+  x=$h
+  while [ -n "$x" ] && [ "$x" -gt 1 ] 2>/dev/null; do fam="$fam$x "; x=$(awk '{print $4}' /proc/$x/stat 2>/dev/null); done
+done
+for p in $pids; do
+  case "$fam" in *" $p "*) continue;; esac
+  echo "BR waiting: pid $p $(tr '\0' ' ' < /proc/$p/cmdline 2>/dev/null | cut -c1-120)"; exit 0
+done
+exit 1

scrapers/mu_b1/challenge_detector_v2.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""ARMED in collect_gh_ir.py 2026-10-14 ~21:50 PT (CoS GO 21:39 PT; re-read showed passive-only markers). Narrowed challenge detector for GH ir_b1 -- written 2026-10-14 after the 21:29:39 PT hard stop.
+
+Why: the v1 CHAL regex in collect_gh_ir.py hard-stops on ANY bare 'recaptcha' / 'hcaptcha' substring anywhere in the
+first 400 KB. repository.parliament.gh is a DSpace 7 (Angular SSR) site whose ~499 KB home page carries inline config /
+cookie-consent / i18n state; DSpace 7 ships a 'google-recaptcha' cookie-consent service and registration-verification
+config, so a bare-word hit there is passive configuration, not an interactive gate (same class as KZN's .wpcf7-recaptcha).
+
+Design (fail closed by default):
+  STRONG  -> hard stop, anywhere in the body: interstitial titles, Cloudflare/Turnstile/Sucuri/Incapsula/DataDome/
+             PerimeterX/AWS-WAF/DDoS-Guard/Imunify/SG markers, and *rendered* captcha widgets (g-recaptcha / h-captcha /
+             cf-turnstile elements with a data-sitekey, or the captcha api.js loaded in a small page).
+  WEAK    -> bare recaptcha/hcaptcha/captcha words. Hard stop ONLY if the page does not look like a real DSpace page
+             (no DSpace generator/app markers) or is small (< 60 KB, typical of an interstitial). Otherwise log WEAK_MARKER
+             and continue.
+  Header checks (cf-mitigated, 403/429/503) stay in the collector unchanged.
+Integration (when CoS arms it): in collect_gh_ir.get() replace `m = CHAL.search(txt[:400000])` with
+`v, m = classify(txt); if v == "challenge": ...hard stop...; elif v == "weak": status(f"WEAK_MARKER ...")`.
+"""
+from __future__ import annotations
+import re
+
+STRONG = re.compile(
+    r"<title[^>]*>\s*(?:Just a moment|Attention Required|Access denied|Please wait|One more step|DDoS-Guard|"
+    r"Checking your browser|Security check|Human verification)|"
+    r"_cf_chl_opt|/cdn-cgi/challenge-platform/|cf-browser-verification|cf_chl_|"
+    r"class=\"[^\"]*\bcf-turnstile\b|challenges\.cloudflare\.com/turnstile|"
+    r"checking your browser before accessing|Enable JavaScript and cookies to continue|"
+    r"sgcaptcha|ddos-guard\.net|_Incapsula_Resource|incapsula incident|px-captcha|captcha-delivery\.com|"
+    r"awswaf|aws-waf-token|imunify360-webshield|sucuri_cloudproxy|"
+    r"class=\"[^\"]*\bg-recaptcha\b[^\"]*\"[^>]*data-sitekey|class=\"[^\"]*\bh-captcha\b[^\"]*\"[^>]*data-sitekey",
+    re.I)
+WIDGET_JS = re.compile(r"(?:www\.google\.com|www\.recaptcha\.net)/recaptcha/api\.js|hcaptcha\.com/1/api\.js", re.I)
+WEAK = re.compile(r"recaptcha|hcaptcha|captcha|bot-check", re.I)
+DSPACE = re.compile(r"<meta[^>]+name=\"Generator\"[^>]+content=\"DSpace|<ds-app\b|dspace-angular|<ds-root\b|"
+                    r"/server/api/core/|ds-themed-|dspace-angular-state", re.I)
+SMALL = 60 * 1024
+
+
+def classify(txt: str, limit: int = 400_000):
+    """Return (verdict, match) with verdict in {'challenge', 'weak', 'clean'}; match is an re.Match or None."""
+    body = txt[:limit]
+    m = STRONG.search(body)
+    if m:
+        return "challenge", m
+    m = WIDGET_JS.search(body)
+    if m and len(txt) < SMALL:
+        return "challenge", m          # captcha api loaded by a small interstitial page
+    w = WEAK.search(body)
+    if w:
+        if len(txt) < SMALL or not DSPACE.search(body):
+            return "challenge", w      # can't prove it's a real content page -> fail closed
+        return "weak", w               # passive marker inside a full DSpace page
+    return "clean", None
+
+
+if __name__ == "__main__":  # offline self-test only; makes no network requests
+    cases = {
+        "cf": ("<html><head><title>Just a moment...</title></head><body><script>window._cf_chl_opt={}</script>", "challenge"),
+        "turnstile": ("<html><div class=\"cf-turnstile\" data-sitekey=\"x\"></div>" + "x" * 100000, "challenge"),
+        "g-widget": ("<html><form><div class=\"g-recaptcha\" data-sitekey=\"k\"></div></form>" + "x" * 100000, "challenge"),
+        "dspace-passive": ("<html><head><meta name=\"Generator\" content=\"DSpace 7.6\"></head><ds-app></ds-app>"
+                           + "x" * 200000 + "{\"name\":\"google-recaptcha\",\"purposes\":[\"registration-password-recovery\"]}", "weak"),
+        "small-weak": ("<html><body>please solve the recaptcha</body>", "challenge"),
+        "big-nondspace-weak": ("<html>" + "x" * 100000 + "recaptcha", "challenge"),
+        "clean": ("<html><meta name=\"Generator\" content=\"DSpace 7\">" + "x" * 100000, "clean"),
+    }
+    bad = 0
+    for k, (t, want) in cases.items():
+        v, _ = classify(t); ok = v == want; bad += not ok
+        print(f"{'ok ' if ok else 'BAD'} {k}: {v} (want {want})")
+    raise SystemExit(1 if bad else 0)

scrapers/mu_b1/classify_mu.py

@@ -0,0 +1,27 @@
+"""Heading-only / repeal-placeholder classification for split_offsets() sections (fix batch 2026-10-24).
+heading_only: the section's first line is a short heading (<= 80 chars after the number, not a fee line or sentence fragment, no closing . ; : ?) and every further non-blank
+line is an ALL-CAPS header (PART / ORDER / SCHEDULE titles) -- i.e. an arrangement-of-sections / table-of-contents entry with no body.
+repealed_placeholder: a section whose body is only 'Omitted' / 'Repealed ...' / 'Revoked ...' and which is NOT inside a TOC block
+(a part where >= 60 % of >= 3 sections are heading-only or placeholders)."""
+import re
+NUM = re.compile(r"^\s*\d{1,3}[A-Z]{0,2}\.\s*")
+PL = re.compile(r"(?i)^\W*(?:omitted|spent|deleted|(?:repealed|revoked|omitted|deleted|lapsed)\b[^\n]{0,120})\W*$"
+               r"|^(?:[–—-]\s*\d{1,3}[A-Z]{0,2}\.?\s*)?[—–-]+\s*$")  # MU Revised Laws print a repealed/spent section as 'N. —' or 'N. – M. —' 
+def _kind(t):
+    ls = t.split("\n"); first = NUM.sub("", ls[0]).strip()
+    prose = [l for l in ls[1:] if l.strip() and (l.strip().upper() != l.strip() or not re.search(r"[A-Z]{2}", l))]
+    if prose: return "body"
+    if PL.match(first): return "placeholder"
+    if re.search(r"(?i)\bcited as\b|\bmeans\b|^in th(?:is|ese)\b", first): return "body"
+    if re.search(r"£|\d+p\b|\?|\b(?:and|or)\s*$", first) or first[:1].islower(): return "body"
+    if len(first) <= 80 and not re.search(r"[.;:?]\s*$", first) and (len(ls) == 1 or not prose): return "heading"
+    return "body"
+def classify(secs):
+    by = {}
+    for s in secs: s["_k"] = _kind(s["text"]); by.setdefault(s["part"], []).append(s["_k"])
+    toc = {p for p, ks in by.items() if len(ks) >= 3 and sum(k != "body" for k in ks) >= 0.6 * len(ks)}
+    for s in secs:
+        k = s.pop("_k")
+        s["body_status"] = ("heading_only" if k == "heading" or (k == "placeholder" and s["part"] in toc)
+                            else "repealed_placeholder" if k == "placeholder" else "body")
+    return secs

scrapers/mu_b1/collect_mu.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""MU mu_b1 collector: consolidated Acts ("Acts A-Z", Revised Laws of Mauritius) from the Attorney General's Office site
+https://attorneygeneral.govmu.org (official). Public pages only: no logins, forms, search endpoints or archives.
+Modes:
+  --catalog-only   fetch the Acts A-Z index, every two-letter sub-page and the Term of Use page -> catalog.json, raw/
+  [--max N]        fetch the next N (default all) catalog PDFs into cache/<sha256>.pdf (resumable; fetched.jsonl)
+Only PDF links under /Documents/Laws of Mauritius/ on the same host are taken; other hosts are never contacted.
+300 MB tree cap: PDFs are cached; once the work tree passes 250 MB the PDF of a text-layer document is removed after its text is
+extracted (its sha256 stays in fetched.jsonl). Exit: 0 done, 3 HARD_STOP, 4 MEM_STOP, 5 tree/RSS cap, 2 other error. Env MU_WORK."""
+import argparse, html, json, os, re, sys, threading, time, hashlib
+from urllib.parse import urljoin, urlsplit, unquote, quote
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from mu_net import Net, HardStop, Skip
+from extract_mu import extract_one
+W = os.environ.get("MU_WORK", ".")
+BASE = "https://attorneygeneral.govmu.org"
+INDEX = "/Pages/Laws%20of%20Mauritius/A-Z%20Acts/ActsAZ.aspx"
+TERMS = "/Pages/Laws%20of%20Mauritius/Constitution/termofuse.aspx"
+TREE_CAP = 300 * 1024 * 1024; SOFT = 250 * 1024 * 1024
+ST = os.path.join(W, "status.txt")
+def status(msg):
+    with open(ST, "a") as f: f.write(f"{time.strftime('%Y-%m-%dT%H:%M:%S%z')} COLLECT {msg}\n")
+STOP = {"mem": False}
+def memwatch():
+    low = None
+    while True:
+        kb = int(re.search(r"MemAvailable:\s+(\d+)", open("/proc/meminfo").read()).group(1))
+        if kb < 1.5 * 1048576:
+            low = low or time.time()
+            if time.time() - low >= 15: STOP["mem"] = True; status(f"MEM_STOP mem_kb={kb}"); return
+        else: low = None
+        time.sleep(3)
+def tree_bytes():
+    return sum(os.path.getsize(os.path.join(dp, f)) for dp, _, fs in os.walk(W) for f in fs)
+def rss_mb():
+    try: return int(re.search(r"VmRSS:\s+(\d+)", open("/proc/self/status").read()).group(1)) / 1024
+    except Exception: return 0
+def norm_url(h):
+    u = urljoin(BASE + "/", html.unescape(h).strip())
+    return u.replace(" ", "%20")  # keep the site's own percent-encoding
+def text_of(t): return re.sub(r"\s+", " ", html.unescape(re.sub(r"<[^>]+>", "", t))).replace("\u200b", "").strip()
+def parse_index(htm):
+    out = []
+    for h, t in re.findall(r'<a[^>]+href="([^"#]+)"[^>]*>(.*?)</a>', htm, re.S):
+        if re.search(r"/A-Z%20Acts/[A-Z]/[A-Za-z]{1,3}\.aspx$", h) or re.search(r"/A-Z Acts/[A-Z]/[A-Za-z]{1,3}\.aspx$", h):
+            u = norm_url(h)
+            if u not in out: out.append(u)
+    return out
+def parse_sub(htm, page):
+    out = []
+    for h, t in re.findall(r'<a[^>]+href="([^"#]+?\.pdf)"[^>]*>(.*?)</a>', htm, re.S | re.I):
+        u = norm_url(h)
+        if urlsplit(u).hostname != urlsplit(BASE).hostname: continue
+        if "/Documents/Laws%20of%20Mauritius/" not in u: continue
+        out.append({"title": text_of(t), "url": u, "page": page, "file": unquote(u.rsplit("/", 1)[1])})
+    return out
+def main():
+    ap = argparse.ArgumentParser(); ap.add_argument("--catalog-only", action="store_true"); ap.add_argument("--max", type=int)
+    a = ap.parse_args()
+    threading.Thread(target=memwatch, daemon=True).start()
+    os.makedirs(os.path.join(W, "raw"), exist_ok=True); os.makedirs(os.path.join(W, "cache"), exist_ok=True)
+    net = Net(W)
+    cat_p = os.path.join(W, "catalog.json"); pages_p = os.path.join(W, "catalog_pages.jsonl")
+    try:
+        if not os.path.exists(cat_p):
+            if not os.path.exists(os.path.join(W, "raw/termofuse.html")):
+                u, st, ct, raw = net.get(BASE + TERMS); open(os.path.join(W, "raw/termofuse.html"), "wb").write(raw)
+            ip = os.path.join(W, "raw/actsaz.html")
+            if not os.path.exists(ip):
+                u, st, ct, raw = net.get(BASE + INDEX); open(ip, "wb").write(raw)
+            subs = parse_index(open(ip, encoding="utf-8", errors="replace").read())
+            status(f"index: {len(subs)} sub-pages")
+            if len(subs) < 50: status(f"INDEX_TOO_SMALL {len(subs)}"); return 2
+            done = {}
+            if os.path.exists(pages_p):
+                for l in open(pages_p): d = json.loads(l); done[d["page"]] = d
+            for sp in subs:
+                if sp in done: continue
+                if STOP["mem"]: return 4
+                u, st, ct, raw = net.get(sp)
+                items = parse_sub(raw.decode("utf-8", "replace"), sp) if st == 200 else []
+                with open(pages_p, "a") as f: f.write(json.dumps({"page": sp, "status": st, "items": items}, ensure_ascii=False) + "\n")
+                done[sp] = {"items": items}
+            seen, cat = set(), []
+            for sp in subs:
+                for x in done[sp]["items"]:
+                    k = unquote(x["url"]).lower()
+                    if k in seen: continue
+                    seen.add(k); x["key"] = hashlib.sha1(x["url"].encode()).hexdigest()[:16]; x["kind"] = "consolidated_act"; cat.append(x)
+            json.dump(cat, open(cat_p, "w"), indent=1, ensure_ascii=False); status(f"CATALOG_DONE items={len(cat)} requests={net.n}")
+        if a.catalog_only: return 0
+        cat = json.load(open(cat_p)); fp = os.path.join(W, "fetched.jsonl")
+        done = set()
+        if os.path.exists(fp):
+            for l in open(fp): done.add(json.loads(l)["key"])
+        todo = [x for x in cat if x["key"] not in done]
+        if a.max: todo = todo[:a.max]
+        status(f"FETCH_START todo={len(todo)} done={len(done)}")
+        for i, x in enumerate(todo, 1):
+            if STOP["mem"]: status("MEM_STOP exit"); return 4
+            tb = tree_bytes()
+            if tb > TREE_CAP: status("TREE_CAP 300 MB reached; stop"); return 5
+            if rss_mb() > 300: status(f"RSS_CAP {rss_mb():.0f} MB; stop"); return 5
+            rec = dict(x)
+            try:
+                u, st, ct, raw = net.get(x["url"])
+                if st != 200 or not raw.startswith(b"%PDF"):
+                    rec.update(status_code=st, error=f"not_pdf ct={ct}")
+                else:
+                    sha = hashlib.sha256(raw).hexdigest(); p = os.path.join(W, "cache", sha + ".pdf")
+                    if not os.path.exists(p):
+                        open(p + ".part", "wb").write(raw); os.replace(p + ".part", p)
+                    tm = extract_one(sha, p)
+                    with open(os.path.join(W, "texts_pre.jsonl"), "a") as tf: tf.write(json.dumps(tm) + "\n")
+                    pruned = False
+                    if tb > SOFT and not tm["needs_ocr"]: os.remove(p); pruned = True
+                    rec.update(final_url=u, sha256=sha, bytes=len(raw), status_code=st, pdf_pruned_for_tree_cap=pruned,
+                               retrieved_at=time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()))
+            except Skip as e:
+                rec.update(error=f"skip: {e}")
+            with open(fp, "a") as f: f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+            if i % 25 == 0: status(f"progress {i}/{len(todo)} requests={net.n} tree_mb={tree_bytes()/1e6:.0f}")
+        status(f"FETCH_DONE fetched={len(todo)} requests={net.n}")
+        return 0
+    except HardStop as e:
+        status(f"HARD_STOP {e}"); open(os.path.join(W, "HARD_STOP"), "w").write(f"{time.strftime('%FT%T%z')} {e}\n"); return 3
+if __name__ == "__main__":
+    sys.exit(main())

scrapers/mu_b1/extract_mu.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""Text-layer extraction for MU mu_b1 (pdftotext -layout, page split on form feeds). A document needs OCR when its text layer is
+missing/thin: mean non-space chars per page < 200, or >= 50 % of pages with < 40 non-space chars. Garble ratio = share of
+characters outside printable Latin-1 + common typographic punctuation. Output cache/text/<sha>.txt + texts.jsonl. Env MU_WORK.
+The collector calls extract_one() right after each download and deletes the PDF of a good text-layer document (300 MB tree cap);
+its result is kept in texts_pre.jsonl and reused here. PDFs are kept only for documents that need OCR."""
+import json, os, re, subprocess, sys
+W = os.environ.get("MU_WORK", ".")
+OKCH = re.compile(r"[\x20-\x7e\xa0-\xff\u2018\u2019\u201c\u201d\u2013\u2014\u2026\u00a3\u20ac\u2022\u00b7\u2122\n\r\t\f]")
+def garble(t):
+    t2 = re.sub(r"\s", "", t)
+    if not t2: return 1.0
+    return round(sum(1 for c in t2 if not OKCH.match(c)) / len(t2), 4)
+def extract_one(sha, pdf):
+    os.makedirs(f"{W}/cache/text", exist_ok=True)
+    p = subprocess.run(["pdftotext", "-layout", "-enc", "UTF-8", pdf, "-"], capture_output=True, timeout=600)
+    txt = p.stdout.decode("utf-8", "replace")
+    pages = txt.split("\f")
+    if pages and not pages[-1].strip(): pages = pages[:-1]
+    nch = [len(re.sub(r"\s", "", pg)) for pg in pages] or [0]
+    thin = sum(1 for c in nch if c < 40)
+    needs = (sum(nch) / len(nch) < 200) or (thin / len(nch) >= 0.5)
+    open(f"{W}/cache/text/{sha}.txt", "w").write(txt)
+    return {"sha256": sha, "pages": len(pages), "chars": sum(nch), "thin_pages": thin, "needs_ocr": needs, "garble": garble(txt), "rc": p.returncode}
+if __name__ == "__main__":
+    pre = {}
+    if os.path.exists(f"{W}/texts_pre.jsonl"):
+        for l in open(f"{W}/texts_pre.jsonl"):
+            d = json.loads(l); pre[d["sha256"]] = d
+    out, seen = [], set()
+    for l in open(f"{W}/fetched.jsonl"):
+        r = json.loads(l)
+        if not r.get("sha256") or r["sha256"] in seen: continue
+        seen.add(r["sha256"]); pdf = f"{W}/cache/{r['sha256']}.pdf"
+        if os.path.exists(pdf): out.append(extract_one(r["sha256"], pdf))
+        elif r["sha256"] in pre and os.path.exists(f"{W}/cache/text/{r['sha256']}.txt"): out.append(pre[r["sha256"]])
+    with open(f"{W}/texts.jsonl", "w") as f:
+        for o in out: f.write(json.dumps(o) + "\n")
+    print(json.dumps({"docs": len(out), "needs_ocr": sum(o["needs_ocr"] for o in out), "garble_gt_0.08": sum(o["garble"] > 0.08 for o in out)}))

scrapers/mu_b1/finalize_mu.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Finalize the MU mu_b1 pack: copy the code bundle into scrapers/mu_b1 (never touching the tip's published scrapers/*.py),
+write manifests (known_gaps.json, changed_ids.json, webmail_redactions.json, mu_b1_code.json, mu_b1_summary.json,
+mu_b1_pii_scan.json, pii_scan_notes.md), update the tip's MANIFEST.json / provenance/changes.json additively when the tip has them,
+then SHA256SUMS over every pack file. Never uploads. Env MU_WORK."""
+import hashlib, json, os, shutil, sys
+from collections import Counter
+from pathlib import Path
+import pyarrow.parquet as pq
+HERE = Path(__file__).resolve().parent; sys.path.insert(0, str(HERE))
+from pii_scan_mu import scan
+W = Path(os.environ.get("MU_WORK", ".")).resolve(); S = json.load(open(W / "stage_summary.json")); P = W / "hf_mu_b1" / S["repo"].split("/")[1]
+TD = W / "tip_stage" / S["parent"][:8]; X = json.load(open(W / "stage_extra.json"))
+M = P / "manifests"; SC = P / "scrapers/mu_b1"
+if SC.exists(): shutil.rmtree(SC)
+SC.mkdir(parents=True)
+for pat in ("*.py", "*.sh", "requirements.txt"):
+    for f in sorted(HERE.glob(pat)): shutil.copy2(f, SC / f.name)
+shutil.copy2(HERE / "README_scrapers.md", SC / "README.md")
+shutil.copy2(HERE / "requirements.txt", P / "scrapers/requirements.txt")
+sh = lambda f: hashlib.sha256(f.read_bytes()).hexdigest()
+json.dump({"bundle": "scrapers/mu_b1", "files": {f.name: sh(f) for f in sorted(SC.iterdir()) if f.is_file()},
+           "requirements": {"scrapers/requirements.txt": sh(P / "scrapers/requirements.txt")},
+           "robots_guard": {"upstream_sha256": "fa8823164631f53174a67a4b100f5278758b151c3e6a522d8c9987bb57753542", "bundled_sha256": sh(SC / "robots_guard.py"),
+                            "change": "cache root default changed from an absolute fleet path to the relative 'legal-corpora' (LEGAL_CORPORA_ROOT overrides); no logic change"}},
+          open(M / "mu_b1_code.json", "w"), indent=1)
+drops = [json.loads(l) for l in open(M / "mu_b1_drops.jsonl")]
+hd = json.load(open(W / "heading_drops.json"))
+dup = [d for d in drops if d["reason"].startswith("duplicate")]
+json.dump({"batch": "mu_b1",
+           "whole_text_fallback_laws": {"count": len(X["whole"]), "items": X["whole"]},
+           "duplicate_drops": {"count": len(dup), "by_reason": dict(Counter(d["reason"] for d in dup)), "items": dup},
+           "other_source_drops": {"count": len(drops) - len(dup), "by_reason": dict(Counter(d["reason"] for d in drops if d not in dup)), "items": [d for d in drops if d not in dup]},
+           "act_number_or_title_mismatch": {"count": len(X["number_issues"]), "note": "listing/file-name number, year or title differs from the printed title block; the printed value is used", "items": X["number_issues"]},
+           "heading_only_rows_dropped": {"count": len(hd), "laws": len({d["law_id"] for d in hd}),
+               "note": "arrangement-of-sections entries with no body; the text stays in laws.text at char_start:char_end", "items": hd}},
+          open(M / "known_gaps.json", "w"), indent=1, ensure_ascii=False)
+A = pq.read_table(P / "data/articles.parquet", columns=["id", "law_id", "metadata_json"]).to_pylist()
+Lr = pq.read_table(P / "data/laws.parquet", columns=["id"]).to_pylist()
+json.dump({"parent": S["parent"], "removed_law_ids": [], "removed_article_ids": [], "changed_live_rows": 0,
+           "added_law_ids": [r["id"] for r in Lr[S["tip_laws"]:]], "added_article_ids": [a["id"] for a in A[S["tip_articles"]:]]},
+          open(M / "changed_ids.json", "w"), indent=1)
+json.dump({"placeholder": "[redacted-webmail]", "total": sum(r["count"] for r in X["webmail"]), "laws": X["webmail"],
+           "note": "free-webmail addresses (standard, typo-domain, truncated, spaced, line-split) redacted in laws.text before splitting, so article slices inherit it; offsets refer to the stored text; no values recorded"},
+          open(M / "webmail_redactions.json", "w"), indent=1)
+hits = scan([str(P / "data/laws.parquet"), str(P / "data/articles.parquet")])
+pj = {"new_fail": sum(h["level"] == "fail" for h in hits), "new_hits": hits}
+json.dump(pj, open(M / "mu_b1_pii_scan.json", "w"), indent=1); json.dump(pj, open(W / "pii_scan.json", "w"), indent=1)
+warn = sorted({h["id"] for h in hits if h["level"] == "warn"})
+(M / "pii_scan_notes.md").write_text("\n".join([
+    "# PII scan notes (batch mu_b1)", "", f"- Scope: every string column of the {S['new_laws']} new law rows and {S['new_articles']} new article rows.",
+    f"- FAIL hits in new rows: {pj['new_fail']}.", f"- WARN hits: {dict(Counter(h['kind'] for h in hits if h['level'] == 'warn'))}.", "",
+    "WARN hits are telephone/fax numbers printed in the Acts themselves (office numbers of public bodies, forms) or P.O. Box addresses "
+    "of institutions; they are official texts and are kept. Values are not reproduced here.", "", "Rows with WARN hits:", ""] + [f"- `{i}`" for i in warn] + [""]))
+S2 = {k: v for k, v in S.items() if k != "quality"}; json.dump(S2, open(M / "mu_b1_summary.json", "w"), indent=1, ensure_ascii=False)
+for f in ("MANIFEST.json", "provenance/changes.json"):
+    if (TD / f).exists():
+        d = json.load(open(TD / f)); (P / f).parent.mkdir(parents=True, exist_ok=True)
+        if isinstance(d, dict):
+            d["mu_b1"] = {"parent": S["parent"], "new_laws": S["new_laws"], "new_articles": S["new_articles"], "laws_rows": S["laws_rows"], "articles_rows": S["articles_rows"]}
+        json.dump(d, open(P / f, "w"), indent=1, ensure_ascii=False)
+files = sorted(f for f in P.rglob("*") if f.is_file() and f.name != "SHA256SUMS" and "__pycache__" not in f.parts)
+(P / "SHA256SUMS").write_text("".join(f"{sh(f)}  {f.relative_to(P)}\n" for f in files))
+print(json.dumps({"finalize": "ok", "files": len(files), "heading_only": len(hd), "whole": len(X["whole"]), "pii_new_fail": pj["new_fail"]}))

scrapers/mu_b1/mu_net.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""Guarded, paced, fail-closed HTTP GET for the SH mu_b1 lane (CoS rules 2026-10-16).
+* shared robots_guard (one-hop patched copy, bundled here as robots_guard.py) checked on EVERY hop; content redirects are
+  followed only on the same host (each hop guarded + paced); a cross-host content redirect is NOT followed (logged, item skipped);
+* pacing max(8 s, Crawl-delay) on one clock, one request in flight; verify=True (certifi); unchanged UA (robots_guard.ROBOTS_UA);
+* HARD_STOP (exit 3 by caller) on 403/429/503, cf-mitigated, challenge page, any cert-verify error, robots unavailable/challenge;
+* transport SSLError / connection reset: ONE retry after 120 s, logged; a 2nd consecutive failure or 3 transport errors total -> HARD_STOP;
+* timeout: one retry, then skip the item.
+Every request is appended to requests.jsonl (url, status, bytes, ct, elapsed; never bodies)."""
+import json, os, re, sys, time, hashlib
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))  # bundled robots_guard.py
+os.environ["LEGAL_CORPORA_ROOT"] = os.path.join(os.path.abspath(os.environ.get("MU_WORK", ".")), "legal-corpora")  # guard cache/logs under the work dir
+import requests
+import robots_guard as rg
+from urllib.parse import urlsplit, urljoin
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from challenge_detector_v2 import STRONG, WIDGET_JS, WEAK
+rg.set_country("mu")
+# MU lane extra interstitial markers (checked on EVERY response incl. robots.txt and non-200 bodies)
+EXTRA = re.compile(r"One moment,? please|rejected request|support id|bot[- ]verification|verify (?:that )?you are (?:a )?human|"
+                   r"Request unsuccessful|Pardon Our Interruption|are you a robot", re.I)
+ROBOTS_FLAG = {"challenge": None}
+_LOGP = {"path": None}
+def _robots_fetch(url):
+    code, text, note = rg._default_fetch(url)
+    row = {"ts": time.strftime("%Y-%m-%dT%H:%M:%S%z"), "kind": "robots", "url": url, "status": code, "bytes": len(text or ""), "note": (note or "")[:200]}
+    v = "clean"
+    if text:
+        v, m = classify(text)
+        if v != "challenge" and EXTRA.search(text[:400_000]): v, m = "challenge", EXTRA.search(text[:400_000]).group(0)
+        row["challenge_verdict"] = v
+        if v == "challenge": row["marker"] = m; ROBOTS_FLAG["challenge"] = url
+    if _LOGP["path"]:
+        with open(_LOGP["path"], "a") as f: f.write(json.dumps(row) + "\n")
+    if v == "challenge": return 0, "", "challenge_on_robots"
+    return code, text, note
+rg._robots_fetcher = _robots_fetch
+MIN_GAP = 8.0
+
+class HardStop(Exception): pass
+class Skip(Exception): pass
+
+def _now(): return time.strftime("%Y-%m-%dT%H:%M:%S%z")
+
+def classify(txt):
+    body = txt[:400_000]
+    m = EXTRA.search(body) if "EXTRA" in globals() else None
+    if m: return "challenge", m.group(0)[:80]
+    m = STRONG.search(body)
+    if m: return "challenge", m.group(0)[:80]
+    m = WIDGET_JS.search(body)
+    if m and len(txt) < 60 * 1024: return "challenge", m.group(0)[:80]
+    w = WEAK.search(body)
+    if w:
+        words = len(re.sub(r"<[^>]+>", " ", body).split())
+        return ("challenge" if len(txt) < 60 * 1024 and words < 300 else "weak"), w.group(0)[:80]
+    return "clean", None
+
+class Net:
+    def __init__(self, work, max_bytes=60_000_000):
+        self.W = work; self.req = os.path.join(work, "requests.jsonl"); self.last = 0.0
+        self.transport_errors = 0; self.n = 0; self.max_bytes = max_bytes
+        self.s = requests.Session(); self.s.headers["User-Agent"] = rg.ROBOTS_UA; _LOGP["path"] = self.req
+    def log(self, row):
+        with open(self.req, "a") as f: f.write(json.dumps({"ts": _now(), **row}, ensure_ascii=False) + "\n")
+    def _pace(self, gap):
+        d = gap - (time.time() - self.last)
+        if d > 0: time.sleep(d)
+    def _one(self, url):
+        d = rg.check(url)
+        if ROBOTS_FLAG["challenge"]:
+            self.log({"url": url, "event": "robots_challenge", "robots_url": ROBOTS_FLAG["challenge"]}); raise HardStop(f"challenge on robots {ROBOTS_FLAG['challenge']}")
+        if d.robots_status == "unavailable":
+            rg.report_blocked(d, caller="mu_net"); self.log({"url": url, "event": "robots_unavailable", "rule": d.rule})
+            raise HardStop(f"robots_unavailable {d.host}: {d.rule}")
+        if not d.allowed:
+            rg.report_blocked(d, caller="mu_net"); self.log({"url": url, "event": "robots_disallowed", "rule": d.rule})
+            raise Skip(f"robots_disallowed {url}")
+        gap = max(MIN_GAP, d.crawl_delay or 0)
+        consecutive = 0
+        for attempt in (1, 2):
+            self._pace(gap); t = time.time()
+            try:
+                r = self.s.get(url, timeout=(20, 120), verify=rg.ca_verify_for(url), allow_redirects=False, stream=True)
+                raw = b""
+                for ch in r.iter_content(65536):
+                    raw += ch
+                    if len(raw) > self.max_bytes: break
+                r.close(); self.last = time.time(); self.n += 1
+                return r, raw, time.time() - t, d
+            except requests.exceptions.SSLError as e:
+                self.last = time.time(); self.n += 1; es = str(e)
+                self.log({"url": url, "event": "ssl_error", "error": es[:300], "attempt": attempt})
+                if re.search(r"CERTIFICATE_VERIFY_FAILED|certificate verify failed|hostname mismatch", es): raise HardStop("cert_verify_error")
+                self.transport_errors += 1
+                if attempt == 2 or self.transport_errors >= 3: raise HardStop(f"transport_ssl x{self.transport_errors}")
+                time.sleep(120)
+            except requests.exceptions.ConnectionError as e:
+                self.last = time.time(); self.n += 1
+                self.log({"url": url, "event": "conn_error", "error": str(e)[:300], "attempt": attempt})
+                self.transport_errors += 1
+                if attempt == 2 or self.transport_errors >= 3: raise HardStop(f"transport_conn x{self.transport_errors}")
+                time.sleep(120)
+            except requests.exceptions.Timeout:
+                self.last = time.time(); self.n += 1
+                self.log({"url": url, "event": "timeout", "attempt": attempt})
+                if attempt == 2: raise Skip(f"timeout x2 {url}")
+        raise Skip("unreachable")
+    def get(self, url):
+        """Returns (final_url, status, content_type, bytes). Raises HardStop / Skip."""
+        hops = 0
+        while True:
+            r, raw, el, d = self._one(url)
+            ct = r.headers.get("Content-Type", ""); loc = r.headers.get("Location")
+            row = {"url": url, "status": r.status_code, "bytes": len(raw), "content_type": ct, "location": loc,
+                   "elapsed_s": round(el, 2), "n": self.n}
+            row["last_modified"] = r.headers.get("Last-Modified")
+            if r.headers.get("cf-mitigated"): self.log(row); raise HardStop("cf-mitigated")
+            if not raw.startswith(b"%PDF"):
+                v0, m0 = classify(raw[:400_000].decode("utf-8", "replace"))
+                if v0 == "challenge": row["challenge_verdict"] = v0; row["marker"] = m0; self.log(row); raise HardStop(f"challenge {url}")
+            if r.status_code in (403, 429, 503): self.log(row); raise HardStop(f"http_{r.status_code} {url}")
+            if r.status_code in (301, 302, 303, 307, 308) and loc:
+                nxt = urljoin(url, loc); self.log(row)
+                if (urlsplit(nxt).hostname or "").lower() != (urlsplit(url).hostname or "").lower():
+                    self.log({"url": url, "event": "cross_host_redirect_not_followed", "location": nxt})
+                    raise Skip(f"cross_host_redirect {nxt}")
+                hops += 1
+                if hops > 5: raise Skip("too_many_redirects")
+                url = nxt; continue
+            if "html" in ct.lower() or raw[:200].lstrip().lower().startswith((b"<!doctype", b"<html")):
+                v, m = classify(raw.decode("utf-8", "replace")); row["challenge_verdict"] = v
+                if v == "challenge": row["marker"] = m; self.log(row); raise HardStop(f"challenge {url}")
+            row["sha256"] = hashlib.sha256(raw).hexdigest(); self.log(row)
+            return url, r.status_code, ct, raw

scrapers/mu_b1/ocr_mu.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+"""OCR MU mu_b1 needs_ocr PDFs (adapted from GH ir_b1 ocr_gh_ir.py) (no usable text layer). Fleet v2 gates: start MemAvailable >= 5.5 GiB held 120 s,
+pause < 4 GiB held 60 s (resume >= 5.5 GiB held 120 s), hard stop < 3 GiB held 15 s, tree RSS cap 1 GiB, disk >= 12,600 MiB,
+10-min requeue. ONE worker, page by page (render 1 page at 300 dpi gray, OCR, delete). Runs inside the pipeline's held slot
+(/dev/shm/mu_b1_job.<pipeline pid>); no new stagger stamp. tesseract: system tessdata (/usr/share/tesseract-ocr/5/tessdata,
+has configs/tsv), -l eng. One-page self-test must return words > 0 before any document; a document with 0 words is NOT
+marked done (fails loud: OCR_EMPTY; > 2 in a row or > 20 % of >= 5 docs -> FATAL rc=4). mean_conf < 80 -> DEGRADED.
+Output cache/ocr/<ident>.txt (+ .json {pages, words, mean_conf, status}). Resumable. Env MU_WORK, MU_PIPE_PID."""
+import json, os, shutil, subprocess, sys, tempfile, threading, time
+from pathlib import Path
+W = Path(os.environ.get("MU_WORK", ".")); OUT = W / "cache/ocr"; OUT.mkdir(parents=True, exist_ok=True)
+TESSDATA = "/usr/share/tesseract-ocr/5/tessdata"
+ST = W / "status.txt"
+def log(m):
+    with open(ST, "a") as f: f.write(time.strftime("%Y-%m-%dT%H:%M:%S%z") + " OCR " + m + "\n")
+def mem():
+    for l in open("/proc/meminfo"):
+        if l.startswith("MemAvailable"): return int(l.split()[1]) / 1048576
+def tree_rss():
+    out = subprocess.run(["ps", "-e", "-o", "pid=,ppid=,rss="], capture_output=True, text=True).stdout.split("\n")
+    rows = [tuple(map(int, l.split())) for l in out if l.strip()]
+    kids, ch = {os.getpid()}, True
+    while ch:
+        ch = False
+        for p, pp, r in rows:
+            if pp in kids and p not in kids: kids.add(p); ch = True
+    return sum(r for p, pp, r in rows if p in kids) / 1024
+def held(t, cond, every=5):
+    t0 = time.time()
+    while time.time() - t0 < t:
+        if not cond(): return False
+        time.sleep(every)
+    return True
+def start_gate():
+    while True:
+        free = shutil.disk_usage(str(W)).free / 1048576
+        if free >= 12600 and held(120, lambda: mem() >= 5.5): return
+        log(f"GATE_WAIT v2 mem={mem():.2f}GiB disk={free:.0f}MiB requeue 600s"); time.sleep(600)
+STOP = threading.Event(); REASON = []; PEAK = [0.0]
+def monitor():
+    low = None
+    while not STOP.is_set():
+        m = mem()
+        if m < 3.0:
+            low = low or time.time()
+            if time.time() - low >= 15: REASON.append(f"HARD_STOP mem={m:.2f}GiB<3.0 held 15s"); STOP.set()
+        else: low = None
+        r = tree_rss(); PEAK[0] = max(PEAK[0], r)
+        if r > 1024: REASON.append(f"RSS_CAP rss={r:.0f}MB"); STOP.set()
+        time.sleep(3)
+def pause_gate():
+    if mem() >= 4.0: return
+    t0 = time.time()
+    while not STOP.is_set() and mem() < 4.0:
+        if time.time() - t0 >= 60:
+            log(f"PAUSE mem={mem():.2f}GiB<4.0 held 60s")
+            while not STOP.is_set():
+                if held(120, lambda: mem() >= 5.5 and not STOP.is_set()): log("RESUME"); return
+            return
+        time.sleep(5)
+TENV = {**os.environ, "TESSDATA_PREFIX": TESSDATA, "OMP_THREAD_LIMIT": "1"}
+def tess_tsv(png):
+    r = subprocess.run(["tesseract", png, "-", "-l", "eng", "--psm", "6", "tsv"], capture_output=True, text=True, timeout=600, env=TENV)
+    return r.stdout, r.stderr
+def parse_tsv(tsv):
+    lines, confs = {}, []
+    for row in tsv.split("\n")[1:]:
+        c = row.split("\t")
+        if len(c) < 12 or c[0] != "5": continue
+        cf = float(c[10]); w = c[11]
+        if cf >= 0 and w.strip(): confs.append(cf); lines.setdefault((int(c[2]), int(c[3]), int(c[4])), []).append(w)
+    return lines, confs
+def check_tess():
+    if not (Path(TESSDATA) / "configs" / "tsv").exists(): log(f"FATAL tessdata {TESSDATA} lacks configs/tsv"); sys.exit(5)
+    r = subprocess.run(["tesseract", "--list-langs"], capture_output=True, text=True, env=TENV)
+    if "eng" not in (r.stdout + r.stderr).split(): log(f"FATAL tesseract lang eng missing prefix={TESSDATA}"); sys.exit(5)
+def render(pdf, p, base):
+    subprocess.run(["pdftoppm", "-r", "300", "-gray", "-f", str(p), "-l", str(p), "-png", "-singlefile", str(pdf), base], check=True, timeout=300)
+def self_test(todo):
+    for i in todo:
+        pdf = W / "cache" / f"{i}.pdf"
+        with tempfile.TemporaryDirectory(dir=str(W)) as td:
+            try: render(pdf, 1, f"{td}/st")
+            except Exception: continue
+            tsv, err = tess_tsv(f"{td}/st.png"); _, confs = parse_tsv(tsv)
+        if not confs: log(f"FATAL SELFTEST words=0 prefix={TESSDATA} pdf={pdf.name} err={err.strip()[:200]!r}"); sys.exit(6)
+        log(f"SELFTEST ok prefix={TESSDATA} lang=eng pdf={pdf.name} p1 words={len(confs)} mean_conf={sum(confs)/len(confs):.1f}"); return
+    log("FATAL SELFTEST no renderable PDF"); sys.exit(6)
+EMPTY, SEEN, RUN = [], [0], [0]
+def done(i):
+    f = OUT / f"{i}.json"
+    try: d = json.loads(f.read_text()); return d.get("words", 0) > 0 or d.get("status") == "FAILED"
+    except Exception: return False
+def ocr_doc(ident):
+    pdf = W / "cache" / f"{ident}.pdf"; texts, confs = [], []
+    info = subprocess.run(["pdfinfo", str(pdf)], capture_output=True, text=True).stdout
+    pl = [l for l in info.split("\n") if l.startswith("Pages")]
+    if not pl:
+        meta = {"ident": ident, "pages": 0, "words": 0, "mean_conf": 0.0, "status": "FAILED", "error": "pdfinfo_no_pages"}
+        (OUT / f"{ident}.json").write_text(json.dumps(meta)); log(f"FAIL {ident} pdfinfo_no_pages"); return meta
+    n = int(pl[0].split()[1])
+    with tempfile.TemporaryDirectory(dir=str(W)) as td:
+        for p in range(1, n + 1):
+            pause_gate()
+            if STOP.is_set(): return None
+            base = f"{td}/p"; render(pdf, p, base)
+            tsv, _ = tess_tsv(base + ".png"); lines, pc = parse_tsv(tsv); confs.extend(pc)
+            texts.append("\n".join(" ".join(v) for k, v in sorted(lines.items())))
+            os.remove(base + ".png")
+    SEEN[0] += 1
+    if not confs:
+        EMPTY.append(ident); RUN[0] += 1
+        log(f"OCR_EMPTY {ident} pages={n} (not marked done)")
+        if RUN[0] > 2 or (SEEN[0] >= 5 and len(EMPTY) / SEEN[0] > 0.20):
+            log(f"FATAL OCR_EMPTY run={RUN[0]} empty={len(EMPTY)}/{SEEN[0]} empties={EMPTY}"); sys.exit(4)
+        return None
+    RUN[0] = 0
+    mc = sum(confs) / len(confs)
+    (OUT / f"{ident}.txt").write_text("\f".join(texts))
+    ver = subprocess.run(["tesseract", "--version"], capture_output=True, text=True).stdout.split()[1]
+    meta = {"ident": ident, "pages": n, "words": len(confs), "mean_conf": round(mc, 2), "status": "ok" if mc >= 80 else "DEGRADED",
+            "engine": f"tesseract {ver}", "lang": "eng", "dpi": 300, "psm": 6, "tessdata": TESSDATA}
+    (OUT / f"{ident}.json").write_text(json.dumps(meta)); log(f"DONE {ident} pages={n} words={len(confs)} conf={mc:.1f} {meta['status']} peak_tree_rss={PEAK[0]:.0f}MB")
+    return meta
+def main():
+    check_tess()
+    todo = []
+    for l in open(W / "texts.jsonl"):
+        d = json.loads(l)
+        if d.get("needs_ocr") and d["sha256"] not in todo: todo.append(d["sha256"])
+    todo = [i for i in todo if not done(i) and (W / "cache" / f"{i}.pdf").exists()]
+    jf = Path(f"/dev/shm/mu_b1_job.{os.environ.get('MU_PIPE_PID', '')}")
+    log(f"MODE v2 5.5/4.0/3.0 rss1024 workers=1 todo={len(todo)} slot={jf.read_text().strip() if jf.exists() else 'NONE'}")
+    if todo and not jf.exists(): log("FATAL no pipeline slot held (run via pipeline_mu.sh)"); sys.exit(7)
+    selftested = False
+    while todo:
+        start_gate()
+        if not selftested: self_test(todo); selftested = True
+        log(f"START todo={len(todo)} mem={mem():.2f}GiB"); STOP.clear(); REASON.clear()
+        th = threading.Thread(target=monitor, daemon=True); th.start()
+        for i in todo:
+            if STOP.is_set(): break
+            ocr_doc(i)
+        STOP.set(); th.join(5)
+        todo = [i for i in todo if not done(i)]
+        if REASON:
+            log("STOPPED " + REASON[0] + f" peak_tree_rss={PEAK[0]:.0f}MB remaining={len(todo)}")
+            if REASON[0].startswith("RSS_CAP"): sys.exit(3)
+            time.sleep(600)
+        elif todo:
+            log(f"EMPTY_LEFT {todo} (not retried in this run)"); break
+    log(f"OCR_DONE remaining={len(todo)} empty={EMPTY}")
+main()

scrapers/mu_b1/pii_scan_mu.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""PII scan for MU mu_b1 shards: every string column of every row. Rows from batch mu_b1 (metadata_json) gate the pack.
+FAIL kinds: email_non_gov (any address that is not a government / institutional domain), phone_mobile (Mauritius mobile:
+8 digits starting 5, optional +230, introduced by a tel/fax cue), name_near_street_address, nic_like (Mauritius National
+Identity Card pattern). WARN kinds: phone_landline (7-digit number introduced by a tel/fax cue), name_near_po_box.
+Output records row id, column, kind and offset only, never the value."""
+import json, re, sys
+from collections import Counter
+import pyarrow.parquet as pq
+GOV = re.compile(r"(?i)@(?:[a-z0-9-]+\.)*(?:govmu\.org|gov\.mu|ac\.mu|int|org)$")
+EMAIL = re.compile(r"[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}")
+PHONE = re.compile(r"(?<![0-9A-Za-z£$.,/])(?:\(?\+?230\)?[\s-]?)?[2-9]\d{2,3}[\s-]?\d{4}(?![0-9A-Za-z])")
+PCUE = re.compile(r"(?i)\b(?:tel|telephone|phone|fax|mobile|cell)\b")
+NIC = re.compile(r"\b[A-Z]\d{12}[A-Z0-9]\b")
+NAME = re.compile(r"\b(?:Mr|Mrs|Ms|Miss|Dr)\.?\s+(?:[A-Z]\.?\s*){0,3}[A-Z][a-z]+")
+STREET = re.compile(r"\b\d{1,5}[A-Za-z]?,?\s+(?:[A-Z][a-z]+\s+){1,3}(?:Street|Road|Avenue|Drive|Lane|Close|Way)\b")
+POBOX = re.compile(r"(?i)\bP\.?\s?[O0]\.?\s?Box\b")
+FAIL = {"email_non_gov", "phone_mobile", "name_near_street_address", "nic_like"}
+def scan_value(v):
+    out = []
+    for m in EMAIL.finditer(v):
+        if not GOV.search(m.group(0)) and "[redacted-webmail]" not in m.group(0): out.append(("email_non_gov", m.start()))
+    for m in PHONE.finditer(v):
+        if not PCUE.search(v[max(0, m.start() - 60): m.start()]): continue
+        d = re.sub(r"\D", "", m.group(0)); d = d[3:] if d.startswith("230") and len(d) > 8 else d
+        out.append(("phone_mobile" if len(d) == 8 and d[0] == "5" else "phone_landline", m.start()))
+    for m in NIC.finditer(v): out.append(("nic_like", m.start()))
+    for m in NAME.finditer(v):
+        ctx = v[max(0, m.start() - 200): m.end() + 200]
+        if STREET.search(ctx): out.append(("name_near_street_address", m.start()))
+        elif POBOX.search(ctx): out.append(("name_near_po_box", m.start()))
+    return out
+def scan(paths):
+    hits = []
+    for p in paths:
+        t = pq.read_table(p); ids = t.column("id").to_pylist(); mj = t.column("metadata_json").to_pylist()
+        new = ['"batch": "mu_b1"' in (x or "") for x in mj]
+        for c in t.column_names:
+            if str(t.schema.field(c).type) not in ("string", "large_string"): continue
+            for rid, v, nw in zip(ids, t.column(c).to_pylist(), new):
+                if v and nw:
+                    for k, o in scan_value(v):
+                        hits.append({"file": p.split("/")[-1], "id": rid, "column": c, "kind": k, "offset": o,
+                                     "level": "fail" if k in FAIL else "warn", "rows": "new"})
+    return hits
+if __name__ == "__main__":
+    h = scan(sys.argv[1:])
+    print(json.dumps({"new_counts": {f"{a}:{b}": n for (a, b), n in Counter((x["level"], x["kind"]) for x in h).items()},
+                      "new_fail": sum(1 for x in h if x["level"] == "fail")}, indent=1))

scrapers/mu_b1/pipeline_mu.sh

@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+# MU mu_b1 chain: catalog -> fetch first 10 + split validation -> fetch (light gate) -> extract -> OCR (v2, only PDFs without a text
+# layer) -> stage (Hub re-read, diff-limited append) -> verify. Never uploads.
+# Usage: MU_WORK=<work dir> bash pipeline_mu.sh   (status lines in $MU_WORK/status.txt: PIPELINE_DONE, HARD_STOP, PARKED, *_FAIL)
+# Fleet gates: light fetch gate MemAvailable >= 4.0 GiB held 120 s, disk >= 12,600 MiB, 300 s stagger on /dev/shm/muni_last_start
+# (stamped ONCE at the real start), one runner slot via flock -n (slot1/2/3 = /dev/shm/muni_runner{,.slot2,.slot3}.lock), yield to
+# Americas BR (bundled br_waiting.sh). In-run: collector hard stop < 1.5 GiB held 15 s and 300 MB tree cap. v2 gate for OCR/stage/
+# verify: start >= 5.5 GiB held 120 s; pause (SIGSTOP) < 4 GiB held 60 s; hard stop < 3 GiB held 15 s; RSS <= 1 GiB.
+set -u; W=$(mkdir -p "${MU_WORK:-.}" && cd "${MU_WORK:-.}" && pwd); HERE=$(cd "$(dirname "$0")" && pwd); export MU_WORK=$W; cd "$W"
+export MU_PIPE_PID=$$
+SHM=${MU_SHM:-/dev/shm}
+unset TESSDATA_PREFIX HTTP_PROXY HTTPS_PROXY http_proxy https_proxy REQUESTS_CA_BUNDLE CURL_CA_BUNDLE HF_HUB_OFFLINE
+log(){ echo "$(date +%FT%T%z) PIPE $*" >> "$W/status.txt"; }
+memkb(){ awk '/MemAvailable/{print $2}' /proc/meminfo; }
+need_kb=$((40*1048576/10))
+memgate(){ local ok_since="" t0 now mem disk; t0=$(date +%s)
+  while :; do mem=$(memkb); disk=$(df -m --output=avail "$W" | tail -1 | tr -d ' '); now=$(date +%s)
+    if [ "$mem" -ge "$need_kb" ] && [ "$disk" -ge 12600 ]; then ok_since=${ok_since:-$now}; [ $((now-ok_since)) -ge 120 ] && return 0; else ok_since=""; fi
+    if [ $((now-t0)) -gt 600 ]; then log "GATE_STALL mem_kb=$mem disk_mib=$disk; requeue 10 min"; sleep 600; t0=$(date +%s); ok_since=""; continue; fi
+    sleep 5; done; }
+v2gate(){ local t0 ok; while :; do t0=$(date +%s); ok=1
+    while [ $(( $(date +%s)-t0 )) -lt 120 ]; do [ "$(memkb)" -ge $((55*1048576/10)) ] || { ok=0; break; }; sleep 5; done
+    [ $ok = 1 ] && return 0; log "V2_GATE_WAIT $1 mem_kb=$(memkb); requeue 10 min"; sleep 600; done; }
+# run a python step under the v2 in-run watchdog
+v2run(){ local name=$1; shift; "$@" & local p=$! low4="" low3="" paused=0 rss
+  while kill -0 $p 2>/dev/null; do m=$(memkb); now=$(date +%s)
+    rss=$(awk '/VmRSS/{print $2}' /proc/$p/status 2>/dev/null || echo 0)
+    if [ "${rss:-0}" -gt 1048576 ]; then log "V2_RSS_STOP $name rss_kb=$rss"; kill $p; wait $p; return 9; fi
+    if [ "$m" -lt $((3*1048576)) ]; then low3=${low3:-$now}; [ $((now-low3)) -ge 15 ] && { log "V2_HARD_STOP $name mem_kb=$m"; kill -CONT $p; kill $p; wait $p; return 9; }; else low3=""; fi
+    if [ "$m" -lt $((4*1048576)) ]; then low4=${low4:-$now}; if [ $paused = 0 ] && [ $((now-low4)) -ge 60 ]; then kill -STOP $p; paused=1; log "V2_PAUSE $name mem_kb=$m"; fi
+    else low4=""; if [ $paused = 1 ] && [ "$m" -ge $((55*1048576/10)) ]; then kill -CONT $p; paused=0; log "V2_RESUME $name mem_kb=$m"; fi; fi
+    sleep 3; done; wait $p; }
+log "PIPELINE_START pid=$$ GATE_WAIT"
+while :; do
+  memgate
+  if why=$("$HERE/br_waiting.sh"); then log "YIELD_BR $why; requeue 10 min"; sleep 600; continue; fi
+  if ls "$SHM"/muni_br/* >/dev/null 2>&1 && find "$SHM/muni_br" -maxdepth 2 -name '*wait*' -newermt '-30 min' 2>/dev/null | grep -q .; then log "YIELD_BR muni_br waiting marker; requeue 10 min"; sleep 600; continue; fi
+  age=$(( $(date +%s) - $(stat -c %Y "$SHM/muni_last_start" 2>/dev/null || echo 0) ))
+  stag_t0=$(date +%s); memok=1
+  while [ "$age" -le 300 ]; do
+    [ "$(memkb)" -ge "$need_kb" ] || { memok=0; break; }
+    [ $(( $(date +%s) - stag_t0 )) -gt 1800 ] && break
+    sleep 5; age=$(( $(date +%s) - $(stat -c %Y "$SHM/muni_last_start" 2>/dev/null || echo 0) ))
+  done
+  [ $memok = 1 ] && [ "$age" -gt 300 ] || continue
+  SLOT=""
+  for s in muni_runner.lock muni_runner.slot2.lock muni_runner.slot3.lock; do exec 9>"$SHM/$s"; if flock -n 9; then SLOT=$s; break; fi; exec 9>&-; done
+  if [ -n "$SLOT" ]; then
+    ( flock -w 30 8 && touch "$SHM/muni_last_start" ) 8>"$SHM/muni_last_start.lock"
+    echo "$SLOT" > "$SHM/mu_b1_job.$$"
+    echo "{\"slot_lock\": \"$SHM/$SLOT\", \"start\": $(date +%s), \"pid\": $$, \"job\": \"mu_b1\"}" > "$SHM/$SLOT.start"
+    log "GATES_OK mem_kb=$(memkb) disk_mib=$(df -m --output=avail "$W" | tail -1 | tr -d ' ') stagger_age=${age}s slot=$SLOT stamp=once"; break
+  fi
+  log "SLOT_BUSY all slots; requeue 10 min"; sleep 600
+done
+trap 'rm -f "$SHM/mu_b1_job.$$"; exec 9>&-' EXIT
+python3 "$HERE"/collect_mu.py --catalog-only > run_catalog.out 2>&1; rc=$?; log "catalog rc=$rc"
+[ $rc -eq 3 ] && { log "HARD_STOP catalog; not continuing"; exit 3; }
+[ -s catalog.json ] || { log "NO_CATALOG stop"; echo "# MU mu_b1 PARKED: no catalog" > PARKED_mu_b1.md; log "PARKED no catalog"; exit 2; }
+if [ ! -f split_validation.json ] || ! python3 -c 'import json,sys; sys.exit(0 if json.load(open("split_validation.json"))["pass"] else 1)'; then
+  python3 "$HERE"/collect_mu.py --max 10 > run_fetch10.out 2>&1; rc=$?; log "fetch10 rc=$rc"
+  [ $rc -eq 3 ] && { log "HARD_STOP fetch10; not continuing"; exit 3; }
+  [ $rc -eq 0 ] || { log "FETCH10_FAIL rc=$rc; stop"; exit 4; }
+  python3 "$HERE"/validate_split_mu.py >> run_validate.out 2>&1; rc=$?; log "split_validation rc=$rc"
+  [ $rc -eq 0 ] || { echo "# MU mu_b1 PARKED: split validation failed on the first 10 PDFs (see split_validation.json)" > PARKED_mu_b1.md; log "PARKED split validation"; exit 7; }
+fi
+for i in $(seq 1 12); do
+  python3 "$HERE"/collect_mu.py > run_fetch.out 2>&1; rc=$?; log "fetch rc=$rc attempt=$i"
+  [ $rc -eq 0 ] && break
+  [ $rc -eq 3 ] && { log "HARD_STOP fetch; not continuing"; exit 3; }
+  [ $rc -eq 5 ] && { echo "# MU mu_b1 PARKED: tree/RSS cap reached during fetch" > PARKED_mu_b1.md; log "PARKED cap"; exit 5; }
+  [ $rc -eq 4 ] && { log "REGATE light gate after MEM_STOP"; memgate; continue; }
+  sleep 600
+done
+[ $rc -eq 0 ] || { log "FETCH_FAIL rc=$rc; stop"; exit 4; }
+python3 "$HERE"/extract_mu.py > run_extract.out 2>&1; rc=$?; log "extract rc=$rc $(tr '\n' ' ' < run_extract.out | cut -c1-200)"
+[ $rc -eq 0 ] || { log "EXTRACT_FAIL rc=$rc"; exit 6; }
+if python3 -c 'import json,sys; sys.exit(0 if any(json.loads(l)["needs_ocr"] for l in open("texts.jsonl")) else 1)'; then
+  v2gate ocr; v2run ocr python3 "$HERE"/ocr_mu.py >> run_ocr.out 2>&1; rc=$?; log "ocr rc=$rc"
+  [ $rc -eq 0 ] || { log "OCR_FAIL rc=$rc; stop before stage"; exit 6; }
+else log "ocr skipped: every PDF has a text layer"; fi
+v2gate stage
+v2run stage python3 "$HERE"/stage_mu.py > run_stage.out 2>&1; rc=$?; log "stage rc=$rc $(tail -c 600 run_stage.out | tr '\n' ' ')"
+[ $rc -eq 0 ] || { log "STAGE_FAIL rc=$rc"; exit 5; }
+v2run verify python3 "$HERE"/verify_mu.py > run_verify.out 2>&1; rc=$?; log "VERIFY rc=$rc $(tail -c 120 run_verify.out | tr '\n' ' ')"
+[ $rc -eq 0 ] && log "PIPELINE_DONE" || log "VERIFY_FAIL rc=$rc"

scrapers/mu_b1/readme_mu.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""Write the cumulative dataset README.md and MANIFEST.md for the MU mu_b1 pack: the tip's own README/MANIFEST are carried
+verbatim (front matter unchanged; the Snapshot rows for laws/articles updated to the new totals) and a batch section is appended
+(sources, licence paraphrase + URL, OCR/text-quality section naming every DEGRADED item, known gaps). Env MU_WORK."""
+import hashlib, json, os, re
+from pathlib import Path
+W = Path(os.environ.get("MU_WORK", ".")).resolve()
+S = json.load(open(W / "stage_summary.json")); P = W / "hf_mu_b1" / S["repo"].split("/")[1]; TD = W / "tip_stage" / S["parent"][:8]
+X = json.load(open(W / "stage_extra.json"))
+rd = (TD / "README.md").read_text() if (TD / "README.md").exists() else "---\nlicense: other\nconfigs:\n- config_name: laws\n  data_files: data/laws.parquet\n  default: true\n- config_name: articles\n  data_files: data/articles.parquet\n---\n"
+rd = re.sub(r"(?m)^\| Laws / instruments \| [\d,]+ \|$", f"| Laws / instruments | {S['laws_rows']:,} |", rd)
+rd = re.sub(r"(?m)^\| Articles \| [\d,]+ \|$", f"| Articles | {S['articles_rows']:,} |", rd)
+deg = S["degraded"]; q = S["quality"]
+L = ["", "## Batch mu_b1 update (AGO consolidated Acts A-Z)", "",
+     f"Diff-limited append on top of `{S['repo']}`@{S['parent'][:12]}: laws/articles {S['tip_laws']}/{S['tip_articles']:,} -> "
+     f"{S['laws_rows']:,}/{S['articles_rows']:,} (new instruments {S['new_laws']}, new article rows {S['new_articles']:,}). Every row already in the dataset is kept unchanged; new rows follow them.", "",
+     "- Source: the Attorney General's Office 'Acts A-Z' pages (attorneygeneral.govmu.org, Laws of Mauritius), one consolidated PDF per Act "
+     "(Revised Laws of Mauritius layout). Live official pages only; robots.txt checked on every hop; no archives, logins or forms.",
+     "- New rows carry `source_type` = `mauritius_ago_revised_laws_acts_az` and `metadata_json.batch` = `mu_b1` (listing page, file name, PDF sha256, Last-Modified, bounds, printed Act number line).",
+     "- Duplicates dropped: identical PDFs, the same Act listed twice under two file names (newest copy kept) and Acts already in this dataset (normalised title + year); see `manifests/mu_b1_drops.jsonl`.",
+     "- Every new article `text` is a verbatim slice `laws.text[char_start:char_end]` (offsets in the article's `metadata_json`, ascending). "
+     "Arrangement-of-sections lines with no body are not articles (listed in `manifests/known_gaps.json`); repealed/spent sections printed as "
+     "'Repealed by ...' or 'N. —' are kept with `metadata_json.body_status` = `repealed_placeholder`; Schedules are separate `-sch` articles.",
+     "- The Act number and year in the listing/file name are checked against the printed title block; mismatches are listed in `manifests/known_gaps.json` (the printed value is used).",
+     "- Free-webmail addresses are redacted as `[redacted-webmail]` (`manifests/webmail_redactions.json`, offsets only).",
+     "- `scrapers/mu_b1/`: complete code for this batch with a how-to-run README; pinned versions in `scrapers/requirements.txt`; file hashes in `manifests/mu_b1_code.json`; `SHA256SUMS` covers every file of the pack.", "",
+     "### License / reuse (batch mu_b1)", "", S["license_paraphrase"], "",
+     "### OCR and text quality (batch mu_b1)", "",
+     f"- Text source: the PDFs' own text layer (pdftotext -layout) for {sum(1 for x in q if x['text_source'] == 'pdf_text_layer')} instruments; tesseract OCR (eng, system tessdata) for {sum(1 for x in q if x['text_source'] == 'ocr')}.",
+     "- DEGRADED means: OCR mean word confidence below 80, or more than 8 % of a text layer's characters outside printable Latin text.",
+     f"- Whole-text fallback (no usable numbered sections, or one section dominating): {S['whole_text_fallback']} instruments (listed in `manifests/known_gaps.json`).", ""]
+L += (["DEGRADED items:", ""] + [f"- {d['title']} ({d['text_source']}, " + (f"confidence {d['mean_conf']}" if d['text_source'] == 'ocr' else f"garble {d['garble']}") + ")" for d in deg] + [""]) if deg else ["DEGRADED items: none.", ""]
+L += ["### Known gaps (batch mu_b1)", "",
+      "- The A-Z pages are the AGO's consolidated set; Acts passed after the last consolidation on the site may be missing or not yet consolidated.",
+      "- Drops by reason: " + ", ".join(f"{k} {v}" for k, v in sorted(S["drops"].items())) + ".", ""]
+(P / "README.md").write_text(rd.rstrip("\n") + "\n" + "\n".join(L))
+md = (TD / "MANIFEST.md").read_text() if (TD / "MANIFEST.md").exists() else "# MANIFEST\n"
+h = lambda p: hashlib.sha256(p.read_bytes()).hexdigest()
+M = ["", "## batch mu_b1 (diff-limited append)", "", f"- parent: {S['parent']}", f"- laws_rows: {S['laws_rows']} (tip {S['tip_laws']}, new {S['new_laws']})",
+     f"- articles_rows: {S['articles_rows']} (tip {S['tip_articles']}, new {S['new_articles']})",
+     f"- laws_sha256: {h(P / 'data/laws.parquet')}", f"- articles_sha256: {h(P / 'data/articles.parquet')}",
+     f"- compression: {S['codec'].lower()}; row groups 1 (copied from the tip)", "- collector: scrapers/mu_b1/collect_mu.py (pipeline scrapers/mu_b1/pipeline_mu.sh)",
+     f"- drops: {json.dumps(S['drops'])}", f"- heading-only rows dropped {S['heading_only_dropped']}; repeal placeholders kept {S['repealed_placeholders']}; schedules {S['schedules']}; whole-text fallback {S['whole_text_fallback']}",
+     "- MANIFEST.json / provenance/changes.json: " + ("updated additively" if any(f in S["tip_files"] for f in ("MANIFEST.json", "provenance/changes.json")) else "not present on the parent commit (not created by this batch)"),
+     "- checksums: SHA256SUMS", ""]
+(P / "MANIFEST.md").write_text(md.rstrip("\n") + "\n" + "\n".join(M))

scrapers/mu_b1/requirements.txt

@@ -0,0 +1,7 @@
+# Exact versions used to build mu_b1 (pip freeze of the libraries the scrapers import; Python 3.10+).
+certifi==2026.7.22
+pyarrow==25.0.1
+PyYAML==6.0.3
+requests==2.34.2
+urllib3==2.8.0
+# System tools (not pip): poppler-utils (pdftotext/pdfinfo/pdftoppm), tesseract 5 + eng tessdata, ripgrep (rg).

scrapers/mu_b1/robots_guard.py

@@ -0,0 +1,1277 @@
+#!/usr/bin/env python3
+"""robots.txt guard for every shared fetch helper (CoS standing rule 2026-10-01).
+
+Rule: before ANY download, fetch and honor the host's robots.txt (incl.
+Crawl-delay), snapshot it with its UTC date, and never fetch a disallowed path
+(report it instead).
+
+What this module does
+* fetches robots.txt once per (scheme, host) and caches it for the run;
+* saves a dated snapshot  <ROOT>/<cc>/logs/robots/<host>_<YYYY-MM-DD UTC>.txt
+  and appends a record to <ROOT>/<cc>/logs/robots/robots_snapshots.jsonl;
+* evaluates rules Google-style (RFC 9309): the most specific matching
+  user-agent group (our UA product names, else "*"), longest-match Allow/Disallow
+  with "*" wildcards and "$" end anchors; Allow wins a length tie.
+  (urllib.robotparser does NOT support * and $, so it is not used.)
+* enforces Crawl-delay as the minimum spacing between requests to that host, with ONE
+  shared per-host last-request clock (thread-safe) used by guard(), wait(), GuardedSession,
+  the guarded_* wrappers and the robots-gated sessions in common / archive_fallbacks: each
+  request waits the Crawl-delay once, measured from the last request to that host. A
+  pre-flight guard(url)/wait(url) followed by the gated send of that request (same thread,
+  same host+path, no other request to the host in between) does not wait a second time;
+* a disallowed URL is NOT fetched: RobotsDisallowed is raised and the event is
+  appended to <ROOT>/<cc>/logs/robots_blocked.jsonl;
+* fails CLOSED when robots.txt answers 5xx / 429 / 401 / 403 / non-200 2xx
+  (e.g. 202 WAF challenge) / an HTML challenge page, times out or errors at the
+  network level (RobotsUnavailable, also logged to robots_blocked.jsonl).
+  404 / 410 (and other 4xx) mean "no rules": allow. A TLS-verification failure
+  is retried unverified for robots.txt only (public file; noted in the log).
+* web.archive.org / Common Crawl / archive.is URLs are hosts like any other (Wayback
+  fetches are subject to web.archive.org's own robots.txt), AND (CoS ruling 2026-10-01) an
+  archive COPY of a URL is only fetched if the ORIGIN's robots.txt allows that URL too:
+  for a Wayback replay URL  http(s)://web.archive.org/web/<ts>[id_|if_|im_|...]/<orig>
+  (or archive.is|ph/<newest|ts>/<orig>) check() also evaluates <orig> against the origin's
+  robots.txt; disallowed -> reason "origin_disallow", origin robots.txt unavailable ->
+  reason "origin_robots_unavailable" (fail closed, same policy). Discovery that downloads
+  no document (Wayback CDX /cdx/search/cdx, calendar /web/*/...) is judged by the archive
+  host's robots.txt only. check_archived_copy(orig, archive_url) does the same for other
+  archive copies (e.g. a Common Crawl WARC record of <orig>).
+* robots_cached carve-out (CoS 2026-10-03), ARCHIVE copies only: every successful robots.txt
+  read (200 rules, or 404/410/other 4xx = allow) is persisted to
+  <ROOT>/logs/robots_snapshots/<host>.json (fetched_at, status, http_status, body); a failed
+  read never overwrites it. When the ORIGIN's robots.txt cannot be read now, an archive copy
+  is judged by that snapshot if it is at most 7 days old (logged as robots_cached; a cached
+  Disallow blocks as origin_disallow); no snapshot or an older one stays fail-closed
+  (origin_robots_unavailable). Direct live fetches to the origin are unchanged (fail closed).
+
+Usage
+    import robots_guard as rg
+    rg.set_country("gt")            # or env ROBOTS_COUNTRY / COLLECTOR_CC
+    rg.guard(url)                   # raises RobotsBlocked, else waits crawl-delay
+    d = rg.check(url)               # Decision(allowed=..., rule=..., ...) no wait/raise
+    s = rg.GuardedSession()         # requests.Session; every send() (incl. each
+                                    # redirect hop) goes through guard()
+    rg.guarded_curl_run(["curl", "-sL", url], capture_output=True)
+                                    # curl never follows redirects itself (-L stripped,
+                                    # --max-redirs 0); the wrapper follows Location hops
+                                    # (max 10), guard()ing each hop incl. Crawl-delay
+    try: ...
+    except rg.RobotsBlocked as e:   # a PermissionError; put it BEFORE `except Exception`
+        rg.log_robots_blocked(e, caller="collect_xx:fetch")   # robots_blocked, not a failure
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import re
+import sys
+import threading
+import time
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Callable, Optional
+from urllib.parse import urlsplit, unquote, quote
+
+ROOT = Path(os.environ.get("LEGAL_CORPORA_ROOT", "legal-corpora"))
+# UA product names we answer to (matched case-insensitively against User-agent lines; RFC 9309 product names).
+OUR_UA_PRODUCTS = ("legal-corpora-collector", "justicedao-legal-corpus")
+ROBOTS_UA = (
+    "legal-corpora-collector/1.0 "
+    "(research archive of official national gazettes; polite; "
+    "contact via local operator)"
+)
+MAX_ROBOTS_BYTES = 512 * 1024  # RFC 9309: parse at least 500 KiB
+ROBOTS_TIMEOUT = (15, 30)
+
+
+class RobotsBlocked(PermissionError):
+    """Base: the guard refused to fetch (do not retry this URL in this run)."""
+
+    def __init__(self, msg: str, decision: "Decision"):
+        super().__init__(msg)
+        self.decision = decision
+
+
+class RobotsDisallowed(RobotsBlocked):
+    pass
+
+
+class RobotsUnavailable(RobotsBlocked):
+    """robots.txt could not be read (5xx / timeout / ...): fail closed."""
+
+
+# ---------------------------------------------------------------- parsing
+
+@dataclass
+class Group:
+    agents: list = field(default_factory=list)
+    rules: list = field(default_factory=list)  # (allow: bool, pattern: str)
+    crawl_delay: Optional[float] = None
+
+
+@dataclass
+class Robots:
+    groups: list
+    sitemaps: list
+    raw_sha256: str = ""
+
+    def select(self, ua_products=OUR_UA_PRODUCTS) -> Optional[Group]:
+        """Merge every group naming our most specific product name; else the * groups."""
+        toks = [t.lower() for t in ua_products]
+        best_len, merged = -1, None
+        for g in self.groups:
+            for a in g.agents:
+                al = a.lower()
+                if al == "*":
+                    continue
+                for t in toks:
+                    # product-name match: the UA line name is a prefix of ours
+                    if t == al or t.startswith(al):
+                        if len(al) > best_len:
+                            best_len, merged = len(al), Group([a], list(g.rules), g.crawl_delay)
+                        elif len(al) == best_len and merged is not None:
+                            merged.rules.extend(g.rules)
+                            if merged.crawl_delay is None:
+                                merged.crawl_delay = g.crawl_delay
+        if merged is not None:
+            return merged
+        star = None
+        for g in self.groups:
+            if "*" in g.agents:
+                if star is None:
+                    star = Group(["*"], list(g.rules), g.crawl_delay)
+                else:
+                    star.rules.extend(g.rules)
+                    if star.crawl_delay is None:
+                        star.crawl_delay = g.crawl_delay
+        return star
+
+
+_LINE = re.compile(r"^\s*([A-Za-z-]+)\s*:\s*(.*?)\s*$")
+
+
+def parse_robots(text: str) -> Robots:
+    groups: list[Group] = []
+    sitemaps: list[str] = []
+    cur: Optional[Group] = None
+    last_was_agent = False
+    text = (text or "")
+    for bom in ("\ufeff", "\u00ef\u00bb\u00bf"):  # BOM, also when mis-decoded as latin-1
+        if text.startswith(bom):
+            text = text[len(bom):]
+    for raw in text.splitlines():
+        line = raw.split("#", 1)[0]
+        m = _LINE.match(line)
+        if not m:
+            continue
+        key, val = m.group(1).lower(), m.group(2)
+        if key in ("user-agent", "useragent", "user agent"):
+            if cur is None or not last_was_agent:
+                cur = Group()
+                groups.append(cur)
+            cur.agents.append(val.strip())
+            last_was_agent = True
+            continue
+        if key == "sitemap":
+            sitemaps.append(val)
+            continue  # sitemap does not end an agent run
+        last_was_agent = False
+        if cur is None:
+            continue  # rules before any User-agent are ignored
+        if key in ("allow", "disallow"):
+            if key == "disallow" and val == "":
+                continue  # "Disallow:" (empty) = allow everything = no rule
+            if val == "" and key == "allow":
+                continue
+            cur.rules.append((key == "allow", val))
+        elif key in ("crawl-delay", "crawl_delay"):
+            try:
+                cur.crawl_delay = float(val)
+            except ValueError:
+                pass
+    sha = hashlib.sha256((text or "").encode("utf-8", "replace")).hexdigest()
+    return Robots(groups, sitemaps, sha)
+
+
+def _norm(s: str) -> str:
+    """Normalise percent-encoding so /a%7Eb and /a~b compare equal."""
+    try:
+        return quote(unquote(s), safe="/?&=;:@!$'()*+,~-._%")
+    except Exception:
+        return s
+
+
+def _glob_prefix(pat: str, s: str, anchored: bool) -> bool:
+    """Wildcard match ('*' = any run) WITHOUT regex backtracking (ReDoS-safe, O(len*len)).
+
+    Unanchored patterns match a prefix of s (implicit trailing '*'); '$' anchors the end.
+    """
+    if not anchored:
+        pat = pat + "*"
+    i = j = 0
+    star, mark = -1, 0
+    n, m = len(pat), len(s)
+    while j < m:
+        if i < n and pat[i] == "*":
+            star, mark = i, j
+            i += 1
+        elif i < n and pat[i] == s[j]:
+            i += 1
+            j += 1
+        elif star != -1:
+            i = star + 1
+            mark += 1
+            j = mark
+        else:
+            return False
+    while i < n and pat[i] == "*":
+        i += 1
+    return i == n
+
+
+_pat_cache: dict = {}
+
+
+def _prep(pattern: str):
+    v = _pat_cache.get(pattern)
+    if v is None:
+        p = _norm(pattern)
+        anchored = p.endswith("$")
+        if anchored:
+            p = p[:-1]
+        p = re.sub(r"\*{2,}", "*", p)
+        v = (p, anchored)
+        if len(_pat_cache) < 50000:
+            _pat_cache[pattern] = v
+    return v
+
+
+def match_rule(group: Optional[Group], path: str):
+    """Return (allowed, matched_rule_str or None). Longest pattern wins; Allow wins ties."""
+    if group is None or not group.rules:
+        return True, None
+    if not path:
+        path = "/"
+    p = _norm(path)
+    best = None  # (len, allow, pattern)
+    for allow, pattern in group.rules:
+        pat = pattern if pattern.startswith(("/", "*")) else "/" + pattern
+        gp, anchored = _prep(pat)
+        if _glob_prefix(gp, p, anchored):
+            ln = len(pattern)
+            if best is None or ln > best[0] or (ln == best[0] and allow and not best[1]):
+                best = (ln, allow, pattern)
+    if best is None:
+        return True, None
+    return best[1], f"{'Allow' if best[1] else 'Disallow'}: {best[2]}"
+
+
+def path_of(url: str) -> str:
+    sp = urlsplit(url)
+    path = sp.path or "/"
+    if sp.query:
+        path += "?" + sp.query
+    return path
+
+
+def evaluate(robots_text: Optional[str], url_or_path: str, ua_products=OUR_UA_PRODUCTS):
+    """Pure helper (used by the audit): (allowed, rule, crawl_delay, agent_group)."""
+    if robots_text is None:
+        return True, None, None, None
+    rb = parse_robots(robots_text)
+    g = rb.select(ua_products)
+    path = path_of(url_or_path) if "://" in url_or_path else url_or_path
+    if path in ("/robots.txt",):
+        return True, None, (g.crawl_delay if g else None), (g.agents[0] if g else None)
+    ok, rule = match_rule(g, path)
+    return ok, rule, (g.crawl_delay if g else None), (g.agents[0] if g else None)
+
+
+# ---------------------------------------------------------------- runtime
+
+@dataclass
+class HostState:
+    origin: str
+    status: str            # ok | missing | unavailable
+    http_status: int = 0
+    robots: Optional[Robots] = None
+    group: Optional[Group] = None
+    crawl_delay: float = 0.0
+    snapshot: str = ""
+    fetched_at: str = ""
+    error: str = ""
+
+
+@dataclass
+class Decision:
+    allowed: bool
+    url: str
+    host: str
+    reason: str            # allowed | disallowed | robots_unavailable
+    rule: Optional[str] = None
+    agent: Optional[str] = None
+    crawl_delay: float = 0.0
+    robots_status: str = ""
+    robots_http_status: int = 0
+    snapshot: str = ""
+    robots_fetched_at: str = ""
+    origin_url: str = ""   # archive copies: the original URL whose origin robots.txt was checked
+    robots_source: str = ""  # "cached" when the origin decision came from a persisted snapshot
+
+
+_lock = threading.RLock()
+_host_locks: dict = {}
+_cache: dict = {}            # origin -> HostState
+_last_req: dict = {}         # host -> monotonic time of last request (THE shared per-host clock)
+_tls = threading.local()     # per-thread pre-flight grant: (host, path, clock stamp)
+_country: Optional[str] = None
+_robots_fetcher: Optional[Callable] = None  # test hook: fn(robots_url) -> (status, text)
+
+
+def set_country(cc: Optional[str]) -> None:
+    global _country
+    _country = (cc or "").strip().lower() or None
+
+
+def _utc_iso() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+
+
+def country() -> str:
+    if _country:
+        return _country
+    for k in ("ROBOTS_COUNTRY", "COLLECTOR_CC", "COUNTRY_CC", "CC"):
+        v = (os.environ.get(k) or "").strip().lower()
+        if re.fullmatch(r"[a-z]{2}", v):
+            return v
+    m = re.search(r"(?:collect|fill|densify|expand|fix)_([a-z]{2})(?:_|\.py|$)", os.path.basename(sys.argv[0] if sys.argv else ""))
+    if m and (ROOT / m.group(1)).is_dir():
+        return m.group(1)
+    m = re.match(r"^_([a-z]{2})_", os.path.basename(sys.argv[0] if sys.argv else ""))
+    if m and (ROOT / m.group(1)).is_dir():
+        return m.group(1)
+    return "_shared"
+
+
+def _logdir() -> Path:
+    cc = country()
+    return (ROOT / "logs") if cc == "_shared" else (ROOT / cc / "logs")
+
+
+def _append_jsonl(path: Path, row: dict) -> None:
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with _lock:
+            with path.open("a", encoding="utf-8") as fh:
+                fh.write(json.dumps(row, ensure_ascii=False) + "\n")
+    except Exception:
+        pass
+
+
+# --- TLS for the robots.txt fetch: always verified (certifi by default), optional per-host CA bundle ----------
+# Hosts whose server omits an intermediate can be given a bundle (certifi/system CAs + that intermediate):
+#   * in code:  robots_guard.set_ca_bundle("www.example.gov", "/path/bundle.pem")  (or update ROBOTS_CA_BUNDLES)
+#   * by env:   ROBOTS_GUARD_CA_BUNDLES='{"www.example.gov": "/path/bundle.pem"}'  or  'host=/path.pem,host2=/p2.pem'
+# A host entry also covers its subdomains ("example.gov" matches "www.example.gov"). A TLS failure is returned like
+# any other fetch error (status 0), so the host is treated as robots-unavailable, i.e. fail closed.
+ROBOTS_CA_BUNDLES: dict = {}
+
+
+def _env_ca_bundles() -> dict:
+    raw = (os.environ.get("ROBOTS_GUARD_CA_BUNDLES") or "").strip()
+    if not raw:
+        return {}
+    try:
+        if raw.startswith("{"):
+            return {str(k).lower(): str(v) for k, v in json.loads(raw).items()}
+        out = {}
+        for part in re.split(r"[,;]", raw):
+            if "=" in part:
+                k, v = part.split("=", 1)
+                out[k.strip().lower()] = v.strip()
+        return out
+    except Exception:
+        return {}
+
+
+def set_ca_bundle(host: str, path) -> None:
+    """Register a CA bundle for host (and its subdomains) for the robots.txt fetch."""
+    ROBOTS_CA_BUNDLES[(host or "").lower().strip(".")] = str(path)
+
+
+def _default_ca() -> object:
+    try:
+        import certifi
+        return certifi.where()
+    except Exception:
+        return True  # requests' own default CA store; still verified
+
+
+def ca_verify_for(url_or_host: str) -> object:
+    """verify= value for requests: the host bundle if one is registered, else certifi. Never False."""
+    host = (urlsplit(url_or_host).hostname if "://" in url_or_host else url_or_host) or ""
+    host = host.lower().strip(".")
+    table = {**_env_ca_bundles(), **ROBOTS_CA_BUNDLES}
+    h = host
+    while h:
+        if h in table and table[h] and os.path.exists(table[h]):
+            return table[h]
+        h = h.split(".", 1)[1] if "." in h else ""
+    return _default_ca()
+
+
+# --- per-host TLS: clear ONLY ssl.VERIFY_X509_STRICT (CoS GO 2026-10-16, Taiwan municipal law hosts) ------------
+# Python 3.13 / urllib3 2.3+ turn on VERIFY_X509_STRICT, which rejects some TW government certificates
+# ("Missing Subject Key Identifier") that OpenSSL otherwise verifies fine. For the EXACT hosts below (no subdomains,
+# no wildcards) the SSL context is the normal urllib3/certifi one with that single flag cleared:
+#   * verify_mode stays ssl.CERT_REQUIRED, check_hostname stays True, the full chain is still verified against
+#     certifi (or the host's registered CA bundle), all other verify_flags (e.g. VERIFY_X509_PARTIAL_CHAIN) unchanged;
+#   * verify=False is refused for these hosts (never used anywhere);
+#   * every use (context build and every request) is appended to <logdir>/tls/tls_relaxed_strict.jsonl.
+# Applied to the robots.txt fetch (_default_fetch) and to GuardedSession (and guarded_get/... wrappers). Not applied
+# to guarded_urlopen / guarded_curl_run (curl uses system OpenSSL, which does not enable X509_STRICT).
+import ssl as _ssl  # noqa: E402
+
+TLS_RELAX_STRICT_HOSTS = frozenset({
+    "laws.gov.taipei",           # Taipei City law system (臺北市法規查詢系統)
+    "www.laws.taipei.gov.tw",    # Taipei legacy host (301 -> laws.gov.taipei)
+    "web.law.ntpc.gov.tw",       # New Taipei City (新北市法規查詢系統)
+    "outlaw.kcg.gov.tw",         # Kaohsiung City (高雄市法規查詢系統)
+})
+
+
+class TLSPolicyError(ValueError):
+    """Refused TLS configuration (e.g. verify=False on a relaxed-strict host, or a host not on the allowlist)."""
+
+
+def tls_relax_strict_allowed(url_or_host: str) -> bool:
+    host = (urlsplit(url_or_host).hostname if "://" in url_or_host else url_or_host) or ""
+    return host.lower().strip(".") in TLS_RELAX_STRICT_HOSTS
+
+
+def _log_tls_relax(row: dict) -> None:
+    _append_jsonl(_logdir() / "tls" / "tls_relaxed_strict.jsonl", {"ts": _utc_iso(), "country": country(), **row})
+
+
+def relaxed_strict_ssl_context(host: str, cafile=None, caller: str = ""):
+    """SSL context for an allowlisted host: default verified context minus VERIFY_X509_STRICT only."""
+    host = (host or "").lower().strip(".")
+    if host not in TLS_RELAX_STRICT_HOSTS:
+        raise TLSPolicyError(f"host not on TLS_RELAX_STRICT_HOSTS: {host!r}")
+    try:
+        from urllib3.util.ssl_ import create_urllib3_context
+        ctx = create_urllib3_context(cert_reqs=_ssl.CERT_REQUIRED)
+    except Exception:  # pragma: no cover - urllib3 missing
+        ctx = _ssl.create_default_context()
+    if cafile is None:
+        cafile = ca_verify_for(host)
+    if isinstance(cafile, str) and os.path.isdir(cafile):
+        ctx.load_verify_locations(capath=cafile)
+    elif isinstance(cafile, str):
+        ctx.load_verify_locations(cafile=cafile)
+    else:
+        ctx.load_default_certs()
+    before = int(ctx.verify_flags)
+    ctx.verify_flags &= ~_ssl.VERIFY_X509_STRICT
+    ctx.verify_mode = _ssl.CERT_REQUIRED
+    ctx.check_hostname = True
+    assert ctx.verify_mode == _ssl.CERT_REQUIRED and ctx.check_hostname
+    assert not (ctx.verify_flags & _ssl.VERIFY_X509_STRICT)
+    _log_tls_relax({"event": "context", "host": host, "caller": caller, "cafile": str(cafile),
+                    "verify_flags_before": before, "verify_flags_after": int(ctx.verify_flags),
+                    "verify_mode": "CERT_REQUIRED", "check_hostname": True})
+    return ctx
+
+
+try:
+    from requests.adapters import HTTPAdapter as _HTTPAdapter
+
+    class _RelaxedStrictAdapter(_HTTPAdapter):
+        """HTTPS adapter bound to ONE allowlisted host; pools use relaxed_strict_ssl_context(host)."""
+
+        def __init__(self, host: str, caller: str = "", **kw):
+            self._rs_host = host.lower().strip(".")
+            if self._rs_host not in TLS_RELAX_STRICT_HOSTS:
+                raise TLSPolicyError(f"host not on TLS_RELAX_STRICT_HOSTS: {host!r}")
+            self._rs_caller = caller
+            super().__init__(**kw)
+
+        def init_poolmanager(self, *a, **kw):
+            kw["ssl_context"] = relaxed_strict_ssl_context(self._rs_host, caller=self._rs_caller)
+            return super().init_poolmanager(*a, **kw)
+
+        def proxy_manager_for(self, proxy, **kw):
+            kw["ssl_context"] = relaxed_strict_ssl_context(self._rs_host, caller=self._rs_caller + ":proxy")
+            return super().proxy_manager_for(proxy, **kw)
+
+        def send(self, request, **kw):
+            host = (urlsplit(request.url).hostname or "").lower()
+            if host != self._rs_host:
+                raise TLSPolicyError(f"relaxed adapter for {self._rs_host} got {host}")
+            if kw.get("verify") is False:
+                _log_tls_relax({"event": "refused_verify_false", "host": host, "url": request.url, "caller": self._rs_caller})
+                raise TLSPolicyError(f"verify=False refused for {host}")
+            _log_tls_relax({"event": "request", "host": host, "method": request.method, "url": request.url,
+                            "caller": self._rs_caller})
+            return super().send(request, **kw)
+
+    class TLSPolicyAdapter(_HTTPAdapter):
+        """Mounted on https:// : allowlisted hosts go through their _RelaxedStrictAdapter, all others unchanged."""
+
+        def __init__(self, caller: str = "", **kw):
+            self._caller, self._relaxed = caller, {}
+            super().__init__(**kw)
+
+        def send(self, request, **kw):
+            host = (urlsplit(request.url).hostname or "").lower().strip(".")
+            if urlsplit(request.url).scheme == "https" and host in TLS_RELAX_STRICT_HOSTS:
+                ad = self._relaxed.get(host)
+                if ad is None:
+                    ad = self._relaxed[host] = _RelaxedStrictAdapter(host, caller=self._caller)
+                return ad.send(request, **kw)
+            return super().send(request, **kw)
+
+        def close(self):
+            for ad in self._relaxed.values():
+                ad.close()
+            super().close()
+except Exception:  # pragma: no cover - requests missing
+    TLSPolicyAdapter = None  # type: ignore
+
+
+def mount_tls_policy(sess, caller: str = ""):
+    """Mount TLSPolicyAdapter on a requests.Session (no-op for objects without .mount, e.g. test fakes)."""
+    if TLSPolicyAdapter is not None and hasattr(sess, "mount"):
+        sess.mount("https://", TLSPolicyAdapter(caller=caller))
+    return sess
+
+
+# --- robots.txt redirect policy (CoS GO 2026-10-14 21:39 PT, "one-hop" fix) ---------------------------------------
+# Redirects on a robots.txt fetch are followed manually, one hop at a time:
+#   * same-host hop (scheme change allowed): followed, at most ROBOTS_MAX_HOPS hops in total;
+#   * cross-host hop: followed ONLY if the target path is exactly "/robots.txt" (that host's robots file);
+#     any other cross-host target (e.g. a bare home page) is NOT fetched -> status 0 -> robots unavailable -> fail closed;
+#   * a repeated URL (loop), > ROBOTS_MAX_HOPS hops or a non-http(s) target -> status 0 -> fail closed;
+#   * every hop after the first waits >= ROBOTS_HOP_MIN_INTERVAL s (and the host's known Crawl-delay) on the shared
+#     per-host clock and stamps it; every hop is appended to <logdir>/robots/robots_fetch_hops.jsonl.
+# Incident: 2026-10-14 ir.parliament.gh/robots.txt 302 -> https://repository.parliament.gh (home page) was fetched
+# before that host's robots.txt had been read, unpaced and unlogged.
+ROBOTS_MAX_HOPS = 5
+ROBOTS_HOP_MIN_INTERVAL = float(os.environ.get("ROBOTS_HOP_MIN_INTERVAL", "8") or 8)
+
+
+def _robots_hop_log(row: dict) -> None:
+    _append_jsonl(_logdir() / "robots" / "robots_fetch_hops.jsonl", {"ts": _utc_iso(), "country": country(), **row})
+
+
+def _robots_hop_clock(url: str, paced: bool) -> None:
+    """Stamp (and, for redirect hops, first wait on) the shared per-host clock. Never touches the thread's grant."""
+    sp = urlsplit(url)
+    host = (sp.hostname or "").lower()
+    st = _cache.get(f"{(sp.scheme or 'http').lower()}://{sp.netloc.lower()}")
+    gap = max(ROBOTS_HOP_MIN_INTERVAL, st.crawl_delay if st else 0.0) if paced else 0.0
+    with _lock:
+        hl = _host_locks.setdefault("wait:" + host, threading.Lock())
+    with hl:
+        last = _last_req.get(host)
+        if gap > 0 and last is not None:
+            delta = gap - (time.monotonic() - last)
+            if delta > 0:
+                time.sleep(delta)
+        _last_req[host] = time.monotonic()
+
+
+def _robots_redirect_refusal(cur: str, nxt: str, seen: set, hops: int) -> str:
+    """'' if the hop cur -> nxt may be fetched, else the fail-closed reason."""
+    sp = urlsplit(nxt)
+    if sp.scheme not in ("http", "https") or not sp.hostname:
+        return f"redirect_to_unsupported_scheme: {nxt}"
+    if nxt in seen:
+        return f"robots_redirect_loop: {nxt}"
+    if hops >= ROBOTS_MAX_HOPS:
+        return "too_many_redirects"
+    if (sp.hostname or "").lower() != (urlsplit(cur).hostname or "").lower() and sp.path != "/robots.txt":
+        return f"robots_redirect_cross_host_not_followed: {nxt}"
+    return ""
+
+
+def _default_fetch(robots_url: str):
+    """Returns (http_status, text, error). Uses a plain session (never guarded).
+    TLS is always verified (per-host CA bundle or certifi). Redirects are followed manually under the one-hop policy
+    above (same host: ok; cross host: only to that host's /robots.txt; else fail closed). Any refusal, loop, network
+    or TLS error returns status 0 => robots unavailable => fail closed."""
+    import requests
+    from urllib.parse import urljoin
+    note = ""
+    try:
+        url, r, hops, seen = robots_url, None, 0, {robots_url}
+        with requests.Session() as sess:
+            mount_tls_policy(sess, caller="robots_fetch")
+            while True:
+                _robots_hop_clock(url, paced=hops > 0)
+                r = sess.get(url, timeout=ROBOTS_TIMEOUT, allow_redirects=False, verify=ca_verify_for(url),
+                             headers={"User-Agent": ROBOTS_UA, "Accept": "text/plain,*/*"}, stream=True)
+                loc = r.headers.get("Location")
+                if r.status_code in (301, 302, 303, 307, 308) and loc:
+                    r.close()
+                    nxt = urljoin(url, loc)
+                    why = _robots_redirect_refusal(url, nxt, seen, hops)
+                    _robots_hop_log({"robots_url": robots_url, "hop": hops, "url": url, "status": r.status_code,
+                                     "location": nxt, "action": "refused" if why else "follow", "reason": why or None})
+                    if why:
+                        return 0, "", why[:300]
+                    if urlsplit(nxt).hostname != urlsplit(url).hostname:
+                        note = f"cross_host_robots_redirect: {nxt}"[:300]
+                    seen.add(nxt); url = nxt; hops += 1
+                    continue
+                if hops:
+                    _robots_hop_log({"robots_url": robots_url, "hop": hops, "url": url, "status": r.status_code,
+                                     "action": "final"})
+                break
+            raw = b""
+            for chunk in r.iter_content(65536):
+                raw += chunk
+                if len(raw) >= MAX_ROBOTS_BYTES:
+                    break
+            r.close()
+        raw = raw[:MAX_ROBOTS_BYTES]
+        try:  # RFC 9309: robots.txt is UTF-8 (strip a BOM)
+            txt = raw.decode("utf-8-sig")
+        except UnicodeDecodeError:
+            txt = raw.decode(r.encoding or "latin-1", "replace")
+        return r.status_code, txt, note
+    except Exception as exc:  # timeout, DNS, TLS (SSLError => fail closed), reset ...
+        return 0, "", f"{type(exc).__name__}: {exc}"[:300]
+
+
+_CHALLENGE = re.compile(r"just a moment|cf-browser-verification|challenge-platform|captcha|awswaf|"
+                        r"checking your browser|enable javascript|request rejected|access denied|"
+                        r"rejected request|support id", re.I)   # + F5 BIG-IP ASM page (CoS 2026-10-16; OCM/Senate KH)
+
+
+def _load_host(origin: str, host: str) -> HostState:
+    with _lock:
+        st = _cache.get(origin)
+        if st is not None:
+            return st
+        hl = _host_locks.setdefault(origin, threading.Lock())
+    with hl:
+        with _lock:
+            st = _cache.get(origin)
+            if st is not None:
+                return st
+        robots_url = origin + "/robots.txt"
+        fetch = _robots_fetcher or _default_fetch
+        code, text, err = fetch(robots_url)
+        now = _utc_iso()
+        looks_html = bool(re.search(r"<\s*(html|!doctype)", (text or "")[:600], re.I))
+        if code == 200 and not looks_html:
+            rb = parse_robots(text)
+            g = rb.select()
+            st = HostState(origin, "ok", code, rb, g, float(g.crawl_delay or 0) if g else 0.0, fetched_at=now, error=err)
+        elif code == 200 and looks_html and _CHALLENGE.search((text or "")[:4000]):
+            st = HostState(origin, "unavailable", code, fetched_at=now, error="waf_challenge_page")
+        elif code == 200 and looks_html:
+            st = HostState(origin, "missing", code, fetched_at=now, error="html_body_treated_as_no_rules")
+        elif code in (401, 403, 429) or code >= 500 or code == 0 or (200 < code < 300):
+            st = HostState(origin, "unavailable", code, fetched_at=now, error=err or f"http_{code}")
+        else:  # 404, 410, other 4xx/3xx-without-target: no rules -> allow
+            st = HostState(origin, "missing", code, fetched_at=now, error=f"http_{code}" + (f";{err}" if err else ""))
+        # dated snapshot (also for missing/unavailable, so the decision is auditable)
+        day = now[:10]
+        safe_host = re.sub(r"[^A-Za-z0-9.-]+", "_", host)
+        snap = _logdir() / "robots" / f"{safe_host}_{day}.txt"
+        try:
+            snap.parent.mkdir(parents=True, exist_ok=True)
+            body = text if st.status == "ok" else f"# robots.txt {robots_url} status={st.status} http={code} {st.error}\n"
+            prev = snap.read_text(encoding="utf-8", errors="replace") if snap.exists() else None
+            if prev != body:
+                snap.write_text(body, encoding="utf-8")
+            st.snapshot = str(snap.relative_to(ROOT))
+        except Exception:
+            pass
+        _append_jsonl(_logdir() / "robots" / "robots_snapshots.jsonl", {
+            "fetched_at": now, "country": country(), "host": host, "robots_url": robots_url,
+            "http_status": code, "status": st.status, "error": st.error or None,
+            "sha256": hashlib.sha256((text or "").encode("utf-8", "replace")).hexdigest() if st.status == "ok" else None,
+            "bytes": len(text or ""), "agent_group": (st.group.agents[0] if st.group else None),
+            "crawl_delay": st.crawl_delay or None, "snapshot": st.snapshot,
+        })
+        if st.status in ("ok", "missing"):
+            _save_persisted_snapshot(origin, host, st, text, robots_url)
+        with _lock:
+            _cache[origin] = st
+        return st
+
+
+CACHED_MAX_AGE_S = 7 * 24 * 3600
+
+
+def _persist_dir() -> Path:
+    return ROOT / "logs" / "robots_snapshots"
+
+
+def _persist_path(host: str) -> Path:
+    return _persist_dir() / (re.sub(r"[^A-Za-z0-9.-]+", "_", host or "_") + ".json")
+
+
+def _save_persisted_snapshot(origin: str, host: str, st: "HostState", text: str, robots_url: str) -> None:
+    """Successful robots.txt read only (status ok / missing): write <host>.json atomically."""
+    try:
+        p = _persist_path(host)
+        p.parent.mkdir(parents=True, exist_ok=True)
+        row = {"host": host, "origin": origin, "robots_url": robots_url, "fetched_at": st.fetched_at,
+               "status": st.status, "http_status": st.http_status,
+               "body": (text or "") if st.status == "ok" else "",
+               "sha256": hashlib.sha256((text or "").encode("utf-8", "replace")).hexdigest() if st.status == "ok" else None}
+        tmp = p.with_name(p.name + f".tmp{os.getpid()}_{threading.get_ident()}")
+        tmp.write_text(json.dumps(row, ensure_ascii=False), encoding="utf-8")
+        os.replace(tmp, p)
+    except Exception:
+        pass
+
+
+def load_persisted_snapshot(host: str) -> Optional[dict]:
+    try:
+        return json.loads(_persist_path(host).read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def _snapshot_age_s(snap: dict) -> Optional[float]:
+    try:
+        t = datetime.fromisoformat(str(snap.get("fetched_at")).replace("Z", "+00:00"))
+        if t.tzinfo is None:
+            t = t.replace(tzinfo=timezone.utc)
+        return (datetime.now(timezone.utc) - t).total_seconds()
+    except Exception:
+        return None
+
+
+def _cached_origin_decision(original_url: str, od: "Decision") -> Optional["Decision"]:
+    """Origin robots.txt unreadable now: decide from a persisted snapshot <= 7 days old, else None."""
+    snap = load_persisted_snapshot(od.host)
+    if not snap or snap.get("status") not in ("ok", "missing"):
+        return None
+    age = _snapshot_age_s(snap)
+    if age is None or age < -300 or age > CACHED_MAX_AGE_S:
+        return None
+    base = dict(url=original_url, host=od.host, robots_status="cached", robots_http_status=int(snap.get("http_status") or 0),
+                snapshot=str(_persist_path(od.host).relative_to(ROOT)) if str(_persist_path(od.host)).startswith(str(ROOT)) else str(_persist_path(od.host)),
+                robots_fetched_at=str(snap.get("fetched_at") or ""), robots_source="cached")
+    if snap.get("status") == "missing" or urlsplit(original_url).path == "/robots.txt":
+        return Decision(True, reason="allowed", rule="cached: no rules", **base)
+    g = parse_robots(snap.get("body") or "").select()
+    ok, rule = match_rule(g, path_of(original_url))
+    return Decision(ok, reason="allowed" if ok else "disallowed", rule=f"cached {snap.get('fetched_at')}: {rule}",
+                    agent=(g.agents[0] if g else None), crawl_delay=float(g.crawl_delay or 0) if g else 0.0, **base)
+
+
+def _log_robots_cached(original_url: str, archive_url: str, cd: "Decision", live: "Decision") -> None:
+    row = {"ts": _utc_iso(), "country": country(), "event": "robots_cached", "status": "robots_cached",
+           "host": cd.host, "url": archive_url, "origin_url": original_url, "allowed": cd.allowed,
+           "rule": cd.rule, "snapshot": cd.snapshot, "snapshot_fetched_at": cd.robots_fetched_at,
+           "live_robots_error": live.rule}
+    _append_jsonl(_logdir() / "robots_cached.jsonl", row)
+    try:
+        import logging
+        logging.getLogger("robots_guard").warning("robots_cached %s %s via snapshot %s (live robots.txt: %s)",
+                                                  "allow" if cd.allowed else "disallow", original_url, cd.robots_fetched_at, live.rule)
+    except Exception:
+        pass
+
+
+def check(url: str) -> Decision:
+    """Decide without waiting or raising (does fetch robots.txt on first use)."""
+    sp = urlsplit(url)
+    scheme = (sp.scheme or "http").lower()
+    host = (sp.hostname or "").lower()
+    if scheme not in ("http", "https") or not host:
+        return Decision(False, url, host, "robots_unavailable", rule="unsupported_url")
+    origin = f"{scheme}://{sp.netloc.lower()}"
+    st = _load_host(origin, host)
+    base = dict(url=url, host=host, crawl_delay=st.crawl_delay, robots_status=st.status,
+                robots_http_status=st.http_status, snapshot=st.snapshot, robots_fetched_at=st.fetched_at)
+    if sp.path == "/robots.txt":
+        return Decision(True, reason="allowed", **base)
+    if st.status == "unavailable":
+        return Decision(False, reason="robots_unavailable", rule=st.error, **base)
+    if st.status == "missing":
+        d = Decision(True, reason="allowed", **base)
+    else:
+        ok, rule = match_rule(st.group, path_of(url))
+        d = Decision(ok, reason="allowed" if ok else "disallowed", rule=rule,
+                     agent=(st.group.agents[0] if st.group else None), **base)
+    if d.allowed:
+        orig = archived_original(url)
+        if orig:
+            return check_archived_copy(orig, url, _archive_decision=d)
+    return d
+
+
+# Archive replay URLs that serve a COPY of <orig> (not discovery listings such as /web/*/...).
+_REPLAY_RES = (
+    re.compile(r"^https?://(?:web|wayback)\.archive\.org/web/\d{1,14}(?:[a-z]{2}_)?/+(?P<orig>.+)$", re.I | re.S),
+    re.compile(r"^https?://(?:www\.)?archive\.(?:is|ph|today|li|vn|fo|md)/(?:newest|oldest|timegate|\d{4,14})/+(?P<orig>.+)$",
+               re.I | re.S),
+)
+
+
+def archived_original(url: str) -> Optional[str]:
+    """The original URL inside an archive replay URL (Wayback /web/<ts>[mod_]/<orig>,
+    archive.is|ph /newest|<ts>/<orig>), else None. Scheme-less originals get http://."""
+    for rx in _REPLAY_RES:
+        m = rx.match(url or "")
+        if not m:
+            continue
+        orig = m.group("orig").strip()
+        orig = re.sub(r"^(https?):/+", lambda mm: mm.group(1).lower() + "://", orig, flags=re.I)
+        if not re.match(r"^https?://", orig, re.I):
+            if re.match(r"^[a-z][a-z0-9+.-]*:", orig, re.I) and not re.match(r"^[^/:]+:\d+(/|$)", orig):
+                return None  # non-http original (mailto:, ftp:, ...): nothing to check
+            orig = "http://" + orig.lstrip("/")
+        return orig
+    return None
+
+
+def check_archived_copy(original_url: str, archive_url: str = "", _archive_decision: Optional[Decision] = None) -> Decision:
+    """May an archive copy of original_url be fetched? Checks the ORIGIN's robots.txt for
+    original_url (fail closed). Returns the archive decision (or an allow) when the origin
+    allows; else a refusing Decision with reason origin_disallow / origin_robots_unavailable."""
+    od = check(original_url)
+    if not od.allowed and od.reason == "robots_unavailable":
+        cd = _cached_origin_decision(original_url, od)  # robots_cached carve-out (archive copies only)
+        if cd is not None:
+            _log_robots_cached(original_url, archive_url or original_url, cd, od)
+            od = cd
+    a = _archive_decision
+    if a is None:
+        sp = urlsplit(archive_url or original_url)
+        a = Decision(True, archive_url or original_url, (sp.hostname or "").lower(), "allowed")
+    if od.allowed:
+        if not a.origin_url:
+            a.origin_url = original_url
+        if od.robots_source:
+            a.robots_source = od.robots_source
+        return a
+    reason = "origin_robots_unavailable" if od.reason in ("robots_unavailable", "origin_robots_unavailable") else "origin_disallow"
+    return Decision(False, a.url, a.host, reason, rule=f"origin {od.host}: {od.reason} ({od.rule})",
+                    agent=od.agent, crawl_delay=a.crawl_delay, robots_status=od.robots_status,
+                    robots_http_status=od.robots_http_status, snapshot=od.snapshot,
+                    robots_fetched_at=od.robots_fetched_at, origin_url=original_url, robots_source=od.robots_source)
+
+
+def _clock(url: str, min_interval: float, send: bool) -> float:
+    """The shared per-host clock. Sleeps until max(Crawl-delay, min_interval) has passed since
+    the last request to this host, then stamps the clock. Returns the seconds slept.
+
+    send=False (pre-flight: guard()/wait()): also leaves a one-shot grant for this thread.
+    send=True  (the actual send: GuardedSession, guarded_* wrappers, gated sessions in
+    common/archive_fallbacks): if this thread holds a grant for the same host+path and no
+    other request to that host was stamped since, the grant is used instead of waiting again
+    (the wait already happened in the pre-flight); the clock is re-stamped at send time.
+    Any send clears the thread's grant, so retries / redirect hops / later requests wait."""
+    sp = urlsplit(url)
+    host = (sp.hostname or "").lower()
+    path = sp.path or "/"
+    origin = f"{(sp.scheme or 'http').lower()}://{sp.netloc.lower()}"
+    st = _cache.get(origin)
+    gap = max(float(min_interval or 0), st.crawl_delay if st else 0.0)
+    with _lock:
+        hl = _host_locks.setdefault("wait:" + host, threading.Lock())
+    slept = 0.0
+    with hl:  # serialises same-host requests across threads
+        if send:
+            g = getattr(_tls, "grant", None)
+            _tls.grant = None
+            if g is not None and g[0] == host and g[1] == path and _last_req.get(host) == g[2]:
+                _last_req[host] = time.monotonic()
+                return 0.0
+        if gap > 0:
+            last = _last_req.get(host)
+            if last is not None:
+                delta = gap - (time.monotonic() - last)
+                if delta > 0:
+                    time.sleep(delta)
+                    slept = delta
+        now = time.monotonic()
+        _last_req[host] = now
+        if not send:
+            _tls.grant = (host, path, now)
+    return slept
+
+
+def wait(url: str, min_interval: float = 0.0) -> None:
+    """Pre-flight: sleep so requests to this host are >= max(Crawl-delay, min_interval) apart
+    (shared per-host clock). The gated send of the same request will not wait again."""
+    _clock(url, min_interval, send=False)
+
+
+def wait_send(url: str, min_interval: float = 0.0) -> float:
+    """Send gate: wait on the shared per-host clock unless this thread's pre-flight
+    guard()/wait() already waited for this request. Returns the seconds slept."""
+    return _clock(url, min_interval, send=True)
+
+
+_blocked_urls: set = set()   # URLs refused by the guard in this process
+
+
+def report_blocked(d: Decision, caller: str = "") -> None:
+    with _lock:
+        _blocked_urls.add(d.url)
+    row = {"ts": _utc_iso(), "country": country(), "event": "guard_refused", "status": "robots_blocked",
+           "host": d.host, "url": d.url,
+           "reason": d.reason, "rule": d.rule, "agent_group": d.agent,
+           "robots_status": d.robots_status, "robots_http_status": d.robots_http_status,
+           "robots_snapshot": d.snapshot, "robots_fetched_at": d.robots_fetched_at,
+           "caller": caller or None}
+    if getattr(d, "origin_url", ""):
+        row["origin_url"] = d.origin_url
+    if getattr(d, "robots_source", ""):
+        row["robots_source"] = d.robots_source
+    _append_jsonl(_logdir() / "robots_blocked.jsonl", row)
+
+
+def guard(url: str, *, min_interval: float = 0.0, caller: str = "") -> Decision:
+    """Call immediately before every request. Raises RobotsBlocked instead of fetching."""
+    d = check(url)
+    if not d.allowed:
+        report_blocked(d, caller)
+        exc = RobotsUnavailable if d.reason in ("robots_unavailable", "origin_robots_unavailable") else RobotsDisallowed
+        raise exc(f"robots guard: {d.reason} {url} ({d.rule})", d)
+    wait(url, min_interval)
+    return d
+
+
+def guard_send(url: str, *, min_interval: float = 0.0, caller: str = "") -> Decision:
+    """guard() for the code that actually sends the request (sessions, wrappers): same
+    robots decision, but uses a pre-flight guard()'s wait instead of waiting twice."""
+    d = check(url)
+    if not d.allowed:
+        report_blocked(d, caller)
+        exc = RobotsUnavailable if d.reason in ("robots_unavailable", "origin_robots_unavailable") else RobotsDisallowed
+        raise exc(f"robots guard: {d.reason} {url} ({d.rule})", d)
+    wait_send(url, min_interval)
+    return d
+
+
+def log_robots_blocked(exc_or_url, caller: str = "", **extra) -> dict:
+    """For a script's `except robots_guard.RobotsBlocked` branch: record the URL as
+    robots_blocked (NOT a fetch failure) in <cc>/logs/robots_blocked.jsonl and return the row.
+
+    The guard has already written an event="guard_refused" row when it raised; this adds an
+    event="script_skipped" row naming the script/function that skipped the URL.
+    """
+    d = getattr(exc_or_url, "decision", None)
+    url = d.url if d is not None else str(exc_or_url)
+    host = d.host if d is not None else (urlsplit(url).hostname or "").lower()
+    row = {"ts": _utc_iso(), "country": country(), "event": "script_skipped", "status": "robots_blocked",
+           "host": host, "url": url,
+           "reason": d.reason if d is not None else "robots_blocked",
+           "rule": d.rule if d is not None else None,
+           "exception": type(exc_or_url).__name__ if isinstance(exc_or_url, BaseException) else None,
+           "caller": caller or None}
+    row.update({k: v for k, v in extra.items() if k not in row})
+    with _lock:
+        _blocked_urls.add(url)
+    _append_jsonl(_logdir() / "robots_blocked.jsonl", row)
+    return row
+
+
+def was_blocked(url: str) -> bool:
+    """True if the guard refused this exact URL earlier in this process."""
+    return url in _blocked_urls
+
+
+def reset_cache() -> None:
+    with _lock:
+        _cache.clear()
+        _last_req.clear()
+        _blocked_urls.clear()
+
+
+try:
+    import requests as _requests
+
+    class GuardedSession(_requests.Session):
+        """requests.Session whose every send() (each redirect hop too) passes guard()."""
+
+        min_interval: float = 0.0
+
+        def __init__(self, *a, **kw):
+            super().__init__(*a, **kw)
+            mount_tls_policy(self, caller="GuardedSession")   # per-host VERIFY_X509_STRICT relax (allowlist only)
+
+        def send(self, request, **kwargs):
+            guard_send(request.url, min_interval=self.min_interval, caller="GuardedSession")
+            return super().send(request, **kwargs)
+except Exception:  # pragma: no cover - requests missing
+    GuardedSession = None  # type: ignore
+
+
+# ---------------------------------------------------------------- drop-in wrappers for our scripts
+# (CoS ruling R1 2026-10-01: our own collector scripts call these instead of requests/urllib/curl directly)
+
+def guarded_request(method: str, url: str, **kwargs):
+    """Drop-in for requests.request(): fresh GuardedSession per call (like requests.api), every hop guarded."""
+    with GuardedSession() as s:
+        return s.request(method=method, url=url, **kwargs)
+
+
+def guarded_get(url: str, params=None, **kwargs):
+    """Drop-in for requests.get()."""
+    return guarded_request("GET", url, params=params, **kwargs)
+
+
+def guarded_head(url: str, **kwargs):
+    """Drop-in for requests.head() (allow_redirects defaults to False, as in requests)."""
+    kwargs.setdefault("allow_redirects", False)
+    return guarded_request("HEAD", url, **kwargs)
+
+
+def guarded_post(url: str, data=None, json=None, **kwargs):
+    """Drop-in for requests.post()."""
+    return guarded_request("POST", url, data=data, json=json, **kwargs)
+
+
+import socket as _socket  # noqa: E402
+import urllib.request as _urlreq  # noqa: E402
+
+
+class _GuardedRedirectHandler(_urlreq.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        guard_send(newurl, caller="guarded_urlopen(redirect)")
+        return super().redirect_request(req, fp, code, msg, headers, newurl)
+
+
+def guarded_urlopen(url, data=None, timeout=_socket._GLOBAL_DEFAULT_TIMEOUT, *, context=None):
+    """Drop-in for urllib.request.urlopen(): guards the URL and every redirect hop."""
+    target = url.full_url if isinstance(url, _urlreq.Request) else str(url)
+    guard_send(target, caller="guarded_urlopen")
+    handlers = [_GuardedRedirectHandler()]
+    if context is not None:
+        handlers.append(_urlreq.HTTPSHandler(context=context))
+    return _urlreq.build_opener(*handlers).open(url, data, timeout)
+
+
+# ---- curl / wget
+# curl short options that take an argument (the rest of the word, or the next word).
+_CURL_SHORT_ARG = set("AbcCdDeEFHKmoPQrtTuUwxXyYz")
+# curl long options that take an argument (anything else is treated as a flag).
+_CURL_LONG_ARG = {
+    "--url", "--user-agent", "--referer", "--header", "--proxy-header", "--output", "--output-dir",
+    "--data", "--data-ascii", "--data-binary", "--data-raw", "--data-urlencode", "--json", "--form",
+    "--form-string", "--cookie", "--cookie-jar", "--max-time", "--connect-timeout", "--retry",
+    "--retry-delay", "--retry-max-time", "--request", "--proxy", "--proxy-user", "--preproxy",
+    "--noproxy", "--cacert", "--capath", "--cert", "--cert-type", "--key", "--key-type", "--pass",
+    "--range", "--write-out", "--dump-header", "--max-filesize", "--limit-rate", "--resolve",
+    "--connect-to", "--interface", "--user", "--config", "--time-cond", "--upload-file",
+    "--max-redirs", "--speed-limit", "--speed-time", "--expect100-timeout", "--keepalive-time",
+    "--ciphers", "--variable", "--trace", "--trace-ascii", "--stderr", "--proto", "--proto-redir",
+    "--pinnedpubkey", "--dns-servers", "--local-port", "--oauth2-bearer", "--quote", "--etag-save",
+    "--etag-compare", "--happy-eyeballs-timeout-ms", "--unix-socket", "--abstract-unix-socket",
+    "--aws-sigv4", "--hsts", "--alt-svc", "--continue-at", "--create-file-mode", "--rate",
+    "--parallel-max", "--mail-from", "--mail-rcpt", "--login-options", "--sasl-authzid",
+}
+_CURL_LOCATION = {"-L", "--location", "--location-trusted"}
+MAX_CURL_HOPS = 10
+_curl_runner: Optional[Callable] = None  # test hook: fn(argv, **kwargs) -> CompletedProcess
+
+
+def _is_curl(args) -> bool:
+    return bool(args) and os.path.basename(str(args[0])) in ("curl", "curl.exe")
+
+
+def _curl_parse(args):
+    """Sanitise a curl argv: drop -L/--location(-trusted) (also inside combined short flags such
+    as -sfL) and any --max-redirs N, then append --max-redirs 0.
+    Returns (new_args, had_location, url_positions_in_new_args, dump_header_path_or_None)."""
+    out = [args[0]]
+    urls = []
+    had_loc = False
+    dump = None
+    i = 1
+    n = len(args)
+    while i < n:
+        a = args[i]
+        if a in _CURL_LOCATION:
+            had_loc = True
+            i += 1
+            continue
+        if a == "--max-redirs":
+            i += 2
+            continue
+        if a.startswith("--"):
+            if a in _CURL_LONG_ARG and i + 1 < n:
+                if a == "--url":
+                    urls.append(len(out) + 1)
+                if a == "--dump-header":
+                    dump = args[i + 1]
+                out += [a, args[i + 1]]
+                i += 2
+                continue
+            out.append(a)
+            i += 1
+            continue
+        if a.startswith("-") and len(a) > 1:
+            kept = "-"
+            takes_next = False
+            j = 1
+            while j < len(a):
+                c = a[j]
+                if c == "L":
+                    had_loc = True
+                    j += 1
+                    continue
+                kept += c
+                if c in _CURL_SHORT_ARG:
+                    rest = a[j + 1:]
+                    if rest:
+                        kept += rest
+                        if c == "D":
+                            dump = rest
+                    else:
+                        takes_next = True
+                        if c == "D" and i + 1 < n:
+                            dump = args[i + 1]
+                    break
+                j += 1
+            if kept != "-":
+                out.append(kept)
+            if takes_next and i + 1 < n:
+                out.append(args[i + 1])
+                i += 2
+            else:
+                i += 1
+            continue
+        if re.match(r"^https?://", a, re.I):
+            urls.append(len(out))
+        out.append(a)
+        i += 1
+    out += ["--max-redirs", "0"]
+    return out, had_loc, urls, dump
+
+
+def curl_precheck(argv):
+    """Guard every http(s) URL a curl/wget argv would fetch BEFORE running it (raises RobotsBlocked).
+
+    For curl it also returns a SANITISED argv: -L/--location is stripped and --max-redirs 0 is
+    appended, so curl itself never follows a redirect. Run the returned argv, or use
+    guarded_curl_run(), which follows redirects itself and guards every hop (Crawl-delay too).
+    """
+    as_str = isinstance(argv, str)
+    import shlex
+    args = shlex.split(argv) if as_str else [str(a) for a in argv]
+    if _is_curl(args):
+        new, _had_loc, urls, _dump = _curl_parse(args)
+        for k in urls:
+            guard(new[k], caller="curl_precheck(curl)")
+        return shlex.join(new) if as_str else new
+    for a in args[1:]:  # wget etc.: guard URL arguments (no redirect rewriting)
+        if re.match(r"^https?://", a, re.I):
+            guard(a, caller=f"curl_precheck({os.path.basename(args[0])})")
+    return argv
+
+
+def _last_header_block(text: str):
+    """(status, headers-dict-lowercase) of the final HTTP response block in a curl -D dump."""
+    blocks = [b for b in re.split(r"\r?\n\r?\n", text or "") if b.strip()]
+    for b in reversed(blocks):
+        lines = b.strip().splitlines()
+        m = re.match(r"^HTTP/\S+\s+(\d{3})", lines[0].strip())
+        if not m:
+            continue
+        hdrs = {}
+        for ln in lines[1:]:
+            if ":" in ln:
+                k, v = ln.split(":", 1)
+                hdrs[k.strip().lower()] = v.strip()
+        return int(m.group(1)), hdrs
+    return 0, {}
+
+
+def guarded_curl_run(argv, *args, **kwargs):
+    """subprocess.run() for a curl/wget argv, robots-guarded.
+
+    curl: -L/--location is stripped and --max-redirs 0 added, so curl never follows a redirect
+    on its own. If the caller asked for -L, the wrapper follows the redirect itself: it reads
+    the Location header (curl -D dump), resolves relative URLs, guard()s every hop (robots rules
+    AND Crawl-delay), and re-runs curl for that hop, up to MAX_CURL_HOPS (10) hops. A disallowed
+    hop raises RobotsBlocked (logged to <cc>/logs/robots_blocked.jsonl) and is never requested.
+    More than 10 hops gives returncode 47 (curl's "too many redirects").
+    """
+    import shlex
+    import subprocess
+    import tempfile
+    from urllib.parse import urljoin
+    runner = _curl_runner or subprocess.run
+    shell_str = isinstance(argv, str)
+    base = shlex.split(argv) if shell_str else [str(a) for a in argv]
+    if not _is_curl(base):
+        curl_precheck(argv)
+        return runner(argv, *args, **kwargs)
+    new, had_loc, urls, user_dump = _curl_parse(base)
+    for k in urls:
+        guard_send(new[k], caller="guarded_curl_run(curl)")
+    if not had_loc or len(urls) != 1 or user_dump == "-":
+        # no -L requested (curl would not have followed either), or several URLs / headers to
+        # stdout (-D -): run once with redirects disabled; a 3xx is returned to the caller as is.
+        cmd = shlex.join(new) if shell_str else new
+        return runner(cmd, *args, **kwargs)
+    pos = urls[0]
+    tmp = None
+    if user_dump is None:
+        fd, tmp = tempfile.mkstemp(prefix="rg_curl_hdr_", suffix=".txt")
+        os.close(fd)
+        new = new[:-2] + ["-D", tmp] + new[-2:]
+        dump = tmp
+    else:
+        dump = user_dump
+    try:
+        current = new[pos]
+        for hop in range(MAX_CURL_HOPS + 1):
+            cmd = list(new)
+            cmd[pos] = current
+            try:
+                open(dump, "w").close()
+            except Exception:
+                pass
+            res = runner(shlex.join(cmd) if shell_str else cmd, *args, **kwargs)
+            try:
+                hdr_text = open(dump, encoding="latin-1").read()
+            except Exception:
+                hdr_text = ""
+            status, hdrs = _last_header_block(hdr_text)
+            loc = hdrs.get("location")
+            if status not in (301, 302, 303, 307, 308) or not loc:
+                return res
+            if hop == MAX_CURL_HOPS:
+                break
+            nxt = urljoin(current, loc)
+            guard_send(nxt, caller=f"guarded_curl_run(redirect hop {hop + 1})")  # robots + Crawl-delay
+            current = nxt
+        msg = f"guarded_curl_run: more than {MAX_CURL_HOPS} redirects ({current})\n"
+        err = res.stderr
+        if isinstance(err, bytes):
+            err = err + msg.encode()
+        elif isinstance(err, str):
+            err = err + msg
+        return subprocess.CompletedProcess(res.args, 47, res.stdout, err)
+    finally:
+        if tmp:
+            try:
+                os.unlink(tmp)
+            except Exception:
+                pass
+
+
+__all__ = [
+    "RobotsBlocked", "RobotsDisallowed", "RobotsUnavailable", "Decision",
+    "parse_robots", "match_rule", "evaluate", "check", "guard", "wait", "guard_send", "wait_send",
+    "archived_original", "check_archived_copy", "load_persisted_snapshot", "CACHED_MAX_AGE_S",
+    "set_country", "country", "report_blocked", "GuardedSession", "reset_cache",
+    "guarded_request", "guarded_get", "guarded_head", "guarded_post", "guarded_urlopen",
+    "curl_precheck", "guarded_curl_run", "log_robots_blocked", "was_blocked", "MAX_CURL_HOPS",
+]

scrapers/mu_b1/split_mu.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""Page-boundary filtering (bounds) and section splitting for MU legislation texts (pdftotext -layout or OCR text, pages split on \\f).
+bounds.trim(pages): drops page-number-only lines and furniture lines repeated on >= 50 % of >= 3 pages (top 3 / bottom 3 lines);
+  returns (text, stats).
+split(text): sections start at a line '   N.  text' / 'N. text' (N = 1..999 with optional capital suffix, e.g. 5A) AFTER the body start
+  (first 'AN ORDINANCE' / 'ORDINANCE to' / 'In exercise of' / 'WHEREAS' / 'BE IT ENACTED' line; else after the 'ARRANGEMENT OF ...'
+  block's last entry; else the start). Numbering must be monotone within a part; a return to 1 after >= 2 opens a new part
+  (subsidiary legislation printed after its Ordinance). The marginal note (previous short non-section line) is the heading."""
+import re
+from collections import Counter
+PNUM = re.compile(r"^\s*(?:-\s*)?\d{1,4}(?:\s*-)?\s*$|^\s*(?:page\s+)?\d{1,4}\s+of\s+\d{1,4}\s*$", re.I)
+def _norm(l): return re.sub(r"\d+", "#", re.sub(r"\s+", " ", l.strip().lower()))
+FOOT = re.compile(r"(?s)[ \t]*\d{0,2}[ \t]*Under section 10 of the Revised Edition of the Laws Ordinance,?\s*1999,?\s+this\s+text\s+is\s+authoritative.{0,200}?as\s+at\s+\d{1,2}\s+[A-Za-z]+\s+\d{4}\.?")
+MUFURN = re.compile(r"^\s*(?:[A-Z]{1,3}\d{0,3}[A-Z]?\s*[–-]\s*\d{1,4}\s*(?:\[\s*Issue\s+\d+\s*\])?|\[\s*Issue\s+\d+\s*\]|Revised Laws of Mauritius)\s*$")
+def trim(pages):
+    nf = 0
+    for i, p in enumerate(pages):
+        pages[i], k = FOOT.subn("", p); nf += k
+    pages = [p.splitlines() for p in pages]
+    cand = Counter()
+    for ls in pages:
+        nz = [l for l in ls if l.strip()]
+        for l in set(_norm(x) for x in nz[:3] + nz[-3:]): cand[l] += 1
+    rep = {k for k, v in cand.items() if len(pages) >= 3 and v >= 0.5 * len(pages) and len(k) > 1 and not re.match(r"^#\.", k)}
+    out, st = [], {"pages": len(pages), "revised_edition_footnotes": nf, "page_number_lines": 0, "furniture_lines": 0, "furniture_patterns": len(rep)}
+    for ls in pages:
+        nz_idx = [i for i, l in enumerate(ls) if l.strip()]
+        edge = set(nz_idx[:3] + nz_idx[-3:])
+        keep = []
+        for i, l in enumerate(ls):
+            if PNUM.match(l) and l.strip(): st["page_number_lines"] += 1; continue
+            if MUFURN.match(l): st["furniture_lines"] += 1; st["mu_furniture_lines"] = st.get("mu_furniture_lines", 0) + 1; continue
+            if i in edge and _norm(l) in rep: st["furniture_lines"] += 1; continue
+            keep.append(l)
+        out.append("\n".join(keep))
+    return "\n".join(out), st
+BODY = re.compile(r"(?m)^\s*(?:AN\s+ORDINANCE\b|.*\bORDINANCE\s+to\b|In\s+exercise\s+of\b|WHEREAS\b|BE\s+IT\s+ENACTED\b|"
+                  r"ENACTED\s+by\b|IT\s+IS\s+ORDERED\b|The\s+Governor.{0,60}\bmakes\b)")
+SEC = re.compile(r"^\s{0,12}(\d{1,3}[A-Z]{0,2})\.(?:\s{1,}|\t)(?=\S)(.*)$")
+def _num(s):
+    m = re.match(r"(\d+)([A-Z]*)", s); return int(m.group(1)), m.group(2)
+def body_start(lines):
+    txt = "\n".join(lines); m = BODY.search(txt)
+    if m: return txt[:m.start()].count("\n")
+    last = None
+    for i, l in enumerate(lines[:400]):
+        if re.search(r"ARRANGEMENT\s+OF\s+(SECTIONS|REGULATIONS|RULES|PARAGRAPHS|CLAUSES|ARTICLES)", l): last = i
+    if last is not None:
+        # MU (Revised Laws): headings are inline ('1.    Short title'), so the TOC and body both start with a '1.' line;
+        # the body starts at the second '1.' line after the ARRANGEMENT block (the first is the TOC's first entry).
+        ones = [i for i in range(last + 1, len(lines)) if re.match(r"^\s{0,12}1\.\s+\S", lines[i])]
+        if len(ones) >= 2: return ones[1]
+        # skip the TOC: entries are 'N.  short heading' lines; body starts at the first line after them that is long prose
+        j = last + 1
+        while j < len(lines) and (not lines[j].strip() or SEC.match(lines[j]) and len(lines[j].strip()) < 90
+                                  or re.fullmatch(r"\s*(PART|SCHEDULE|Schedule)\b.*", lines[j]) or len(lines[j].strip()) < 60):
+            j += 1
+        return j
+    return 0
+def split(text):
+    lines = text.splitlines(); b = body_start(lines)
+    secs, part, prev, cur = [], 1, None, None
+    ptitle = {1: ""}
+    for i in range(b, len(lines)):
+        l = lines[i]; m = SEC.match(l)
+        ok = False
+        if m:
+            n, suf = _num(m.group(1))
+            if prev is None: ok = n == 1 or n <= 3
+            else:
+                pn, ps = prev
+                if (n == pn + 1) or (n == pn and suf > ps) or (n == pn + 2):
+                    ok = True
+                elif n == 1 and pn >= 2:
+                    ok = True; part += 1
+                    pt = ""
+                    for k in range(i - 1, max(b, i - 40) - 1, -1):
+                        x = lines[k].strip()
+                        if len(x) >= 6 and x.upper() == x and re.search(r"[A-Z]{3}", x) and not SEC.match(lines[k]):
+                            pt = x; break
+                    ptitle[part] = pt
+        if ok:
+            n, suf = _num(m.group(1))
+            j = i - 1
+            while j >= b and not lines[j].strip(): j -= 1
+            head = lines[j].strip() if j >= b and len(lines[j].strip()) < 90 and not SEC.match(lines[j]) and not lines[j].strip().endswith((";", ",")) else ""
+            if cur and head and cur["lines"] and cur["lines"][-1].strip() == head: cur["lines"].pop()
+            cur = {"num": m.group(1), "part": part, "heading": head, "lines": [l.strip()]}
+            secs.append(cur); prev = (n, suf)
+        elif cur is not None:
+            cur["lines"].append(l.rstrip())
+    out = []
+    for s in secs:
+        t = re.sub(r"\n{3,}", "\n\n", "\n".join(s["lines"])).strip()
+        out.append({"num": s["num"], "part": s["part"], "part_title": ptitle.get(s["part"], ""), "heading": s["heading"], "text": t})
+    return out
+def split_offsets(text):
+    """Same section logic as split(), but every section is returned as character offsets [start, end) into `text` itself,
+    so text[start:end] is a verbatim raw slice (no reflow, no normalisation). Fix batch 2026-10-24 (CoS verification)."""
+    lines = text.split("\n"); pos = [0]
+    for l in lines: pos.append(pos[-1] + len(l) + 1)
+    b = body_start(lines)
+    secs, part, prev, cur = [], 1, None, None
+    ptitle = {1: ""}
+    for i in range(b, len(lines)):
+        l = lines[i]; m = SEC.match(l); ok = False
+        if m:
+            n, suf = _num(m.group(1))
+            if prev is None: ok = n == 1 or n <= 3
+            else:
+                pn, ps = prev
+                if (n == pn + 1) or (n == pn and suf > ps) or (n == pn + 2): ok = True
+                elif n == 1 and pn >= 2:
+                    ok = True; part += 1; pt = ""
+                    for k in range(i - 1, max(b, i - 40) - 1, -1):
+                        x = lines[k].strip()
+                        if len(x) >= 6 and x.upper() == x and re.search(r"[A-Z]{3}", x) and not SEC.match(lines[k]): pt = x; break
+                    ptitle[part] = pt
+        if ok:
+            j = i - 1
+            while j >= b and not lines[j].strip(): j -= 1
+            head = lines[j].strip() if j >= b and len(lines[j].strip()) < 90 and not SEC.match(lines[j]) and not lines[j].strip().endswith((";", ",", ".", ":", "—", "-")) else ""
+            if cur and head and j in cur["li"] and cur["li"][0] != j: cur["li"] = cur["li"][:cur["li"].index(j)]
+            cur = {"num": m.group(1), "part": part, "heading": head, "li": [i]}
+            secs.append(cur); prev = (_num(m.group(1)))
+        elif cur is not None:
+            cur["li"].append(i)
+    out = []
+    for s in secs:
+        i0, i1 = s["li"][0], s["li"][-1]
+        st = pos[i0] + (len(lines[i0]) - len(lines[i0].lstrip()))
+        en = pos[i1] + len(lines[i1])
+        while en > st and text[en - 1].isspace(): en -= 1
+        out.append({"num": s["num"], "part": s["part"], "part_title": ptitle.get(s["part"], ""), "heading": s["heading"],
+                    "start": st, "end": en, "text": text[st:en]})
+    return out

scrapers/mu_b1/stage_mu.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""Stage MU mu_b1 as a diff-limited append to endomorphosis/ipfs_mauritius_laws (CoS uploads; this script never uploads).
+* Re-reads the Hub tip right before staging (api/datasets/<repo>); a 401/404 is ambiguous for an existing repo -> REFUSED.
+* Downloads the tip's data/laws.parquet, data/articles.parquet, README.md, MANIFEST.md (+ MANIFEST.json / provenance/changes.json
+  if the tip has them) into tip_stage/<sha8>/; live rows are carried cell-identical; schema (incl. metadata), codec and row-group
+  layout are copied from the tip; new rows are appended after them.
+* New rows: consolidated Acts from the AGO 'Acts A-Z' pages. Dedupe: PDF sha256; same Act (normalised title + Act number/Cap or
+  year) within the batch (keep the newest Last-Modified, then the longer text); against the tip (normalised title + year).
+* Verbatim-slice gate, heading-only drop, repeal-placeholder tag, dominant-article demotion, page-furniture gate, Bills out,
+  free-webmail redaction (manifest without '@'), Act number/year check against the printed title, -dupN ids.
+* Stage only if material (>= 1 new law) AND laws_rows_out >= tip laws_rows. Env MU_WORK."""
+import hashlib, json, os, re, shutil, sys, urllib.request, urllib.error, subprocess, unicodedata
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+import pyarrow as pa, pyarrow.parquet as pq
+HERE = Path(__file__).resolve().parent; sys.path.insert(0, str(HERE))
+import split_mu as S, articles_mu as A, webmail_mu as WM
+W = Path(os.environ.get("MU_WORK", ".")).resolve()
+REPO = os.environ.get("MU_REPO", "endomorphosis/ipfs_mauritius_laws")
+PACK = W / "hf_mu_b1" / REPO.split("/")[1]
+TERMS_URL = "https://attorneygeneral.govmu.org/Pages/Laws%20of%20Mauritius/Constitution/termofuse.aspx"
+LIC = ("Consolidated Acts of Mauritius as published by the Attorney General's Office (attorneygeneral.govmu.org). Described, not quoted: "
+       "the site's Term of Use lets people make personal copies and printouts of the legislation under the Copyright Act, but publishing, "
+       "disseminating or incorporating it for commercial use needs the prior approval of the Solicitor General; the site also says that "
+       "only the LexisNexis 2016 Revised Laws of Mauritius (with their supplements) are the authoritative text, so these copies are for "
+       "information only. Terms: " + TERMS_URL + " . Not legal advice.")
+MON = {m: i for i, m in enumerate(["january","february","march","april","may","june","july","august","september","october","november","december"], 1)}
+FURN_LEFT = re.compile(r"(?m)^\s*(?:[A-Z]{1,3}\d{0,3}[A-Z]?\s*[–-]\s*\d{1,4}\s*\[\s*Issue\s+\d+\s*\]|\[\s*Issue\s+\d+\s*\])\s*$")
+def utc(): return datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z")
+def api(repo):
+    try:
+        with urllib.request.urlopen(f"https://huggingface.co/api/datasets/{repo}", timeout=60) as r: return json.load(r)
+    except urllib.error.HTTPError as e:
+        return {"_http": e.code}
+def dl(repo, sha, f, dst, required=True):
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if not dst.exists():
+        try: urllib.request.urlretrieve(f"https://huggingface.co/datasets/{repo}/resolve/{sha}/{f}", dst)
+        except urllib.error.HTTPError as e:
+            if required: raise
+            return None
+    return dst
+def layout(p):
+    md = pq.ParquetFile(p).metadata
+    return {"rows": md.num_rows, "row_groups": md.num_row_groups, "codec": md.row_group(0).column(0).compression if md.num_row_groups else None,
+            "rg_rows": [md.row_group(i).num_rows for i in range(md.num_row_groups)]}
+def slug(s, n=80):
+    s = unicodedata.normalize("NFKD", s).encode("ascii", "ignore").decode()
+    return re.sub(r"-+", "-", re.sub(r"[^a-z0-9]+", "-", s.lower())).strip("-")[:n].strip("-")
+def ntitle(t):
+    t = unicodedata.normalize("NFKD", t or "").encode("ascii", "ignore").decode().lower()
+    t = re.sub(r"\b(?:no\.?|act|cap\.?|of)\b|\b\d+[a-z]?\b", " ", t); t = re.sub(r"\([^)]*\b(?:act|of)\b[^)]*\)", " ", t)
+    return re.sub(r"[^a-z]+", "", t)
+NUMRX = re.compile(r"(?i)\b(Act|Ordinance|Decree|Order|Government Notice|GN)\s+(?:No\.?\s*)?(\d{1,4})\s+of\s+(1[6-9]\d\d|20[0-4]\d)\b")
+CAPRX = re.compile(r"(?i)\bCap\.?\s*(\d{1,4}[A-Z]?)\b")
+def printed(text):
+    """Printed title block: first caps title line(s) and the 'Act N of YYYY – <date>' / 'Cap N' line under it."""
+    h = text.splitlines()[:30]; out = {}
+    for i, l in enumerate(h):
+        m = NUMRX.search(l); c = CAPRX.search(l)
+        if (m or c) and len(l.strip()) < 120:
+            if m: out.update(kind=m.group(1), number=m.group(2), year=int(m.group(3)), line=l.strip())
+            if c: out.update(cap=c.group(1), line=l.strip())
+            d = re.search(r"(\d{1,2})\s+(" + "|".join(MON) + r")\s+((?:1[6-9]|20)\d\d)", l, re.I)
+            if d: out["date"] = f"{int(d.group(3)):04d}-{MON[d.group(2).lower()]:02d}-{int(d.group(1)):02d}"
+            tl = [x.strip() for x in h[max(0, i - 3):i] if x.strip() and x.strip().upper() == x.strip() and re.search(r"[A-Z]{3}", x)]
+            if tl: out["title"] = " ".join(tl)
+            break
+    return out
+def from_file(name):
+    o = {}; m = re.search(r"(?i)\bNo\.?\s*(\d{1,4})\s+of\s+(1[6-9]\d\d|20[0-4]\d)", name) or re.search(r"(?i)\bAct\s+(\d{1,4})\s+of\s+(1[6-9]\d\d|20[0-4]\d)", name)
+    if m: o.update(number=m.group(1), year=int(m.group(2)))
+    c = CAPRX.search(name)
+    if c: o["cap"] = c.group(1)
+    return o
+FR = re.compile(r"(?i)\b(?:le|la|les|des|du|est|sont|dans|pour|par|qui|une|aux|sera|article)\b")
+EN = re.compile(r"(?i)\b(?:the|of|and|shall|to|in|be|by|any|which|section)\b")
+def lang(text):
+    s = text[:20000]; f, e = len(FR.findall(s)), len(EN.findall(s)); return "fr" if f > 1.5 * e else "en"
+def is_bill(title, text):
+    first = "\n".join(text.splitlines()[:25])
+    return bool(re.search(r"(?i)\bbill\b", title) or re.search(r"(?m)^\s*(?:A\s+)?BILL\b|^\s*A\s+Bill\s+(?:for|to)\b", first))
+def clean_title(t):
+    t = re.sub(r"\s+", " ", (t or "").replace("\u200b", "")).strip(" -–,")
+    return t
+def main():
+    cat = {x["key"]: x for x in json.load(open(W / "catalog.json"))}
+    fetched = [json.loads(l) for l in open(W / "fetched.jsonl")]
+    texts = {}
+    for l in open(W / "texts.jsonl"): d = json.loads(l); texts[d["sha256"]] = d
+    lm = {}
+    for l in open(W / "requests.jsonl"):
+        d = json.loads(l)
+        if d.get("last_modified"): lm[d["url"]] = d["last_modified"]
+    tip = api(REPO)
+    if "_http" in tip or not tip.get("sha"):
+        print(json.dumps({"stage": "REFUSED", "why": f"hub api {tip.get('_http')} for existing repo: ambiguous"})); return 2
+    parent = tip["sha"]; sibs = {s["rfilename"] for s in tip.get("siblings", [])}
+    td = W / "tip_stage" / parent[:8]
+    base_l = dl(REPO, parent, "data/laws.parquet", td / "data/laws.parquet"); base_a = dl(REPO, parent, "data/articles.parquet", td / "data/articles.parquet")
+    for f in ("README.md", "MANIFEST.md", "MANIFEST.json", "provenance/changes.json"):
+        if f in sibs: dl(REPO, parent, f, td / f)
+    TL, TA = pq.read_table(base_l), pq.read_table(base_a)
+    tip_rows = TL.to_pylist()
+    ids = set(TL.column("id").to_pylist()); aids_all = set(TA.column("id").to_pylist())
+    NONACT = re.compile(r"(?i)explanatory|guidance|report|\bbill\b|speech|press|notice|circular")
+    tip_keys = {}
+    for r in tip_rows:
+        if NONACT.search((r["id"] or "") + " " + (r["source_url"] or "") + " " + (r["title"] or "")): continue
+        k = ntitle(r["title"]); 
+        if not k: continue
+        yrs = set(int(y) for y in re.findall(r"\b(1[6-9]\d\d|20[0-4]\d)\b", (r["title"] or "") + " " + (r["official_identifier"] or "")))
+        tip_keys.setdefault(k, []).append((r["id"], yrs))
+    cands, drops, seen_sha, num_issues = [], [], set(), []
+    for r in fetched:
+        x = cat.get(r["key"], r)
+        if not r.get("sha256"): drops.append({"key": r["key"], "url": x["url"], "reason": "fetch_" + (r.get("error") or "no_pdf").split()[0]}); continue
+        if r["sha256"] in seen_sha: drops.append({"key": r["key"], "url": x["url"], "reason": "duplicate_pdf_sha256"}); continue
+        seen_sha.add(r["sha256"]); tm = texts.get(r["sha256"], {}); src = "pdf_text_layer"; ocr = None
+        if tm.get("needs_ocr"):
+            oj = W / "cache/ocr" / f"{r['sha256']}.json"
+            if not oj.exists(): drops.append({"key": r["key"], "url": x["url"], "reason": "needs_ocr_no_ocr_output"}); continue
+            ocr = json.loads(oj.read_text())
+            if ocr.get("status") == "FAILED" or not ocr.get("words"): drops.append({"key": r["key"], "url": x["url"], "reason": "ocr_failed"}); continue
+            raw = (W / "cache/ocr" / f"{r['sha256']}.txt").read_text(); src = "ocr"
+        else:
+            raw = (W / "cache/text" / f"{r['sha256']}.txt").read_text()
+        pages = raw.split("\f")
+        if pages and not pages[-1].strip(): pages = pages[:-1]
+        text, bst = S.trim(pages); text = text.replace("\r", "")
+        text, wrec = WM.redact(text)
+        title = clean_title(x.get("title")) or re.sub(r"\.pdf$", "", x.get("file", ""), flags=re.I)
+        if is_bill(title, text): drops.append({"key": r["key"], "url": x["url"], "title": title, "reason": "bill"}); continue
+        if len(re.sub(r"\s", "", text)) < 200: drops.append({"key": r["key"], "url": x["url"], "title": title, "reason": "empty_text"}); continue
+        pr = printed(text); ff = from_file(x.get("file", "") + " " + x.get("title", ""))
+        mism = []
+        if ff.get("number") and pr.get("number") and (ff["number"], ff["year"]) != (pr["number"], pr["year"]): mism.append("number_year")
+        if ff.get("cap") and pr.get("cap") and ff["cap"].upper() != pr["cap"].upper(): mism.append("cap")
+        if pr.get("title") and ntitle(pr["title"]) and ntitle(title) and ntitle(pr["title"]) != ntitle(title): mism.append("title")
+        if mism: num_issues.append({"key": r["key"], "url": x["url"], "title": title, "printed_title": pr.get("title"), "mismatch": mism,
+                                    "listing_number": ff, "printed_number": {k: pr.get(k) for k in ("kind", "number", "year", "cap")}})
+        offid = (f"{pr['kind'].title() if pr['kind'] not in ('GN',) else 'GN'} {pr['number']} of {pr['year']}" if pr.get("number") else None)
+        if pr.get("cap"): offid = (offid + f" (Cap {pr['cap']})") if offid else f"Cap {pr['cap']}"
+        year = pr.get("year") or ff.get("year")
+        key = (ntitle(title), pr.get("number") or ff.get("number") or pr.get("cap") or ff.get("cap") or "", year or "")
+        cands.append(dict(r=r, x=x, text=text, bst=bst, wrec=wrec, title=title, pr=pr, ff=ff, offid=offid, year=year, key=key, src=src, ocr=ocr, tm=tm,
+                          lm=lm.get(r.get("final_url") or x["url"]) or ""))
+    # in-batch duplicate Acts (same Act listed twice under different file names)
+    def lmkey(c):
+        try: return datetime.strptime(c["lm"], "%a, %d %b %Y %H:%M:%S %Z").timestamp()
+        except Exception: return 0
+    groups = {}
+    for c in cands: groups.setdefault((c["key"][0], c["key"][1], c["key"][2]) if c["key"][1] or c["key"][2] else (c["key"][0], c["r"]["sha256"]), []).append(c)
+    keep = []
+    for k, g in groups.items():
+        g.sort(key=lambda c: (lmkey(c), len(c["text"])), reverse=True); keep.append(g[0])
+        for c in g[1:]: drops.append({"key": c["r"]["key"], "url": c["x"]["url"], "title": c["title"], "reason": "duplicate_act_in_batch", "kept_url": g[0]["x"]["url"]})
+    keep.sort(key=lambda c: fetched.index(c["r"]))
+    laws, arts, quality, heading_drops, whole_list, red_manifest = [], [], [], [], [], []
+    def uid(base):
+        i, x = 1, base
+        while x in ids: i += 1; x = f"{base}-dup{i}"
+        ids.add(x); return x
+    for c in keep:
+        k = c["key"][0]; hit = None
+        for tid, yrs in tip_keys.get(k, []):
+            if not yrs or not c["year"] or c["year"] in yrs: hit = tid; break
+        if hit: drops.append({"key": c["r"]["key"], "url": c["x"]["url"], "title": c["title"], "reason": "duplicate_of_tip", "tip_id": hit}); continue
+        text = c["text"]
+        if FURN_LEFT.search(text): print(json.dumps({"stage": "REFUSED", "why": "page_furniture_left", "url": c["x"]["url"]})); return 2
+        base = "mu-ago-" + (f"act-{c['pr']['number']}-{c['pr']['year']}-" if c["pr"].get("number") else (f"cap-{c['pr']['cap'].lower()}-" if c["pr"].get("cap") else "")) + slug(c["title"], 70)
+        lid = uid(base)
+        al, dl_, whole_reason = A.build(lid, text, c["offid"], c["r"].get("final_url") or c["x"]["url"])
+        # article ids must be unique across the whole articles file too
+        for a in al:
+            if a["id"] in aids_all:
+                b0, i = a["id"], 2
+                while f"{b0}-dup{i}" in aids_all: i += 1
+                a["id"] = f"{b0}-dup{i}"
+            aids_all.add(a["id"])
+        viol = A.gate(text, al)
+        if viol: print(json.dumps({"stage": "REFUSED", "why": "substring_gate", "law": lid, "violations": viol[:5]})); return 2
+        if A.dominant(al): print(json.dumps({"stage": "REFUSED", "why": "dominant_article", "law": lid})); return 2
+        heading_drops.extend(dl_)
+        if whole_reason: whole_list.append({"law_id": lid, "title": c["title"], "reason": whole_reason})
+        if c["wrec"]: red_manifest.append({"law_id": lid, "count": len(c["wrec"]), "categories": dict(Counter(w["category"] for w in c["wrec"])),
+                                           "spans_in_stored_text": [[w["new_start"], w["new_end"]] for w in c["wrec"]]})
+        lg = lang(text)
+        ocr = c["ocr"]; tmv = c["tm"]
+        meta = {"batch": "mu_b1", "kind": "consolidated_act", "listing_page": c["x"].get("page"), "catalog_url": c["x"]["url"], "file_name": c["x"].get("file"),
+                "final_url": c["r"].get("final_url"), "sha256": c["r"]["sha256"], "bytes": c["r"].get("bytes"), "last_modified": c["lm"] or None,
+                "pages": c["bst"]["pages"], "text_source": c["src"], "ocr": ocr, "garble": tmv.get("garble"), "bounds": c["bst"],
+                "printed_identifier_line": c["pr"].get("line"), "printed_title": c["pr"].get("title"), "listing_number": c["ff"],
+                "number_check": "mismatch" if any(n["key"] == c["r"]["key"] for n in num_issues) else ("ok" if (c["pr"].get("number") or c["pr"].get("cap")) else "no_printed_number"),
+                "year": c["year"], "edition": "Revised Laws of Mauritius (AGO consolidated text)", "authoritative_text": "LexisNexis 2016 Revised Laws of Mauritius (per AGO Term of Use)",
+                "webmail_redactions": len(c["wrec"]), "sections": len(al), "heading_only_dropped": len(dl_), "whole_text_fallback": bool(whole_reason),
+                "whole_text_reason": whole_reason, "language_detected": lg,
+                "commencement_date_printed": c["pr"].get("date")}  # date on the printed "Act N of YYYY – <date>" line is the commencement date, not the date of issue
+        laws.append({"id": lid, "title": c["title"], "text": text, "source_url": c["r"].get("final_url") or c["x"]["url"],
+                     "source_type": "mauritius_ago_revised_laws_acts_az", "jurisdiction": "MU", "country": "Mauritius", "language": lg, "eli": None,
+                     "date": None, "date_issued": None, "retrieved_at": c["r"].get("retrieved_at"), "license": LIC, "law_status": "current",
+                     "identifier": lid, "official_identifier": c["offid"], "article_count": len(al), "json_path": None,
+                     "metadata_json": json.dumps(meta, ensure_ascii=False)})
+        arts.extend(al)
+        st = "ok"
+        if c["src"] == "ocr": st = "DEGRADED" if (ocr.get("mean_conf") or 0) < 80 else "ok"
+        elif (tmv.get("garble") or 0) > 0.08: st = "DEGRADED"
+        quality.append({"id": lid, "title": c["title"], "text_source": c["src"], "garble": tmv.get("garble"), "mean_conf": (ocr or {}).get("mean_conf"),
+                        "sections": len(al), "whole": bool(whole_reason), "status": st})
+    tip_laws = TL.num_rows
+    if not laws or tip_laws + len(laws) < tip_laws:
+        print(json.dumps({"stage": "NOT_MATERIAL", "new_laws": len(laws)})); return 2
+    OL = pa.concat_tables([TL, pa.Table.from_pylist(laws, schema=TL.schema)])
+    OA = pa.concat_tables([TA, pa.Table.from_pylist(arts, schema=TA.schema)])
+    if PACK.exists(): shutil.rmtree(PACK)
+    (PACK / "data").mkdir(parents=True); (PACK / "manifests").mkdir()
+    LL, LA = layout(base_l), layout(base_a)
+    if LL["row_groups"] != 1 or LA["row_groups"] != 1: print(json.dumps({"stage": "REFUSED", "why": "tip has >1 row group; layout copy not implemented", "l": LL, "a": LA})); return 2
+    pq.write_table(OL, PACK / "data/laws.parquet", compression=LL["codec"].lower(), row_group_size=OL.num_rows)
+    pq.write_table(OA, PACK / "data/articles.parquet", compression=LA["codec"].lower(), row_group_size=OA.num_rows)
+    with open(PACK / "manifests/mu_b1_drops.jsonl", "w") as f:
+        for d in drops: f.write(json.dumps(d, ensure_ascii=False) + "\n")
+    json.dump(heading_drops, open(W / "heading_drops.json", "w"), ensure_ascii=False)
+    json.dump({"whole": whole_list, "number_issues": num_issues, "webmail": red_manifest}, open(W / "stage_extra.json", "w"), ensure_ascii=False, indent=1)
+    summ = {"batch": "mu_b1", "repo": REPO, "mode": "append", "parent": parent, "tip_files": sorted(sibs), "tip_laws": tip_laws, "tip_articles": TA.num_rows,
+            "new_laws": len(laws), "new_articles": len(arts), "laws_rows": OL.num_rows, "articles_rows": OA.num_rows,
+            "languages": dict(Counter(l["language"] for l in laws)), "drops": dict(Counter(d["reason"] for d in drops)),
+            "quality": quality, "whole_text_fallback": len(whole_list), "degraded": [q for q in quality if q["status"] == "DEGRADED"],
+            "ocr_used": [q for q in quality if q["text_source"] == "ocr"], "codec": LL["codec"], "row_groups": 1,
+            "heading_only_dropped": len(heading_drops), "repealed_placeholders": sum('"repealed_placeholder"' in a["metadata_json"] for a in arts),
+            "schedules": sum('"schedule": true' in a["metadata_json"] for a in arts), "number_mismatches": len(num_issues),
+            "webmail_redactions": sum(r["count"] for r in red_manifest), "license_paraphrase": LIC, "terms_url": TERMS_URL, "staged_at": utc()}
+    json.dump(summ, open(W / "stage_summary.json", "w"), indent=1, ensure_ascii=False)
+    subprocess.run([sys.executable, str(HERE / "readme_mu.py")], check=True)
+    subprocess.run([sys.executable, str(HERE / "finalize_mu.py")], check=True)
+    print(json.dumps({k: summ[k] for k in ("parent", "tip_laws", "tip_articles", "new_laws", "new_articles", "laws_rows", "articles_rows", "drops", "whole_text_fallback", "heading_only_dropped", "number_mismatches")}, ensure_ascii=False))
+    return 0
+if __name__ == "__main__":
+    sys.exit(main())

scrapers/mu_b1/validate_split_mu.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""Pre-stage validation on the first fetched PDFs (CoS rule): each must give a usable text (layer or flagged for OCR) and, for
+text-layer documents, >= 1 numbered section with verbatim slices (articles_mu.build + gate), the first section numbered 1, and no section text empty.
+PASS when >= 80 % of text-layer docs split into >= 2 sections. Writes split_validation.json. Env MU_WORK."""
+import json, os, sys, subprocess
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import split_mu as S
+import articles_mu as A
+W = Path(os.environ.get("MU_WORK", "."))
+rows = []
+for l in open(W / "fetched.jsonl"):
+    r = json.loads(l)
+    if not r.get("sha256"): rows.append({"key": r["key"], "title": r.get("title"), "ok": None, "why": r.get("error")}); continue
+    t = subprocess.run(["pdftotext", "-layout", "-enc", "UTF-8", str(W / "cache" / f"{r['sha256']}.pdf"), "-"], capture_output=True).stdout.decode("utf-8", "replace")
+    pages = [p for p in t.split("\f")]
+    if pages and not pages[-1].strip(): pages = pages[:-1]
+    if sum(len(p.strip()) for p in pages) < 200 * max(1, len(pages)) * 0.5:
+        rows.append({"key": r["key"], "title": r.get("title"), "ok": None, "why": "needs_ocr"}); continue
+    text = S.trim(pages)[0]
+    arts, dropped, whole = A.build("v", text, "", "")
+    secs = [a for a in arts if not json.loads(a["metadata_json"])["schedule"]]
+    nums = [a["article_number"] for a in secs]
+    ok = (whole is None and len(secs) >= 2 and nums[0] == "1" and all(a["text"].strip() for a in arts) and not A.gate(text, arts))
+    rows.append({"key": r["key"], "title": r.get("title"), "ok": ok, "sections": len(secs), "dropped_heading_only": len(dropped),
+                 "whole_reason": whole, "first_nums": nums[:3], "first": [json.loads(a["metadata_json"])["heading"][:60] for a in secs[:3]]})
+tl = [x for x in rows if x["ok"] is not None]
+p = bool(tl) and sum(1 for x in tl if x["ok"]) / len(tl) >= 0.8
+json.dump({"pass": p, "docs": rows}, open(W / "split_validation.json", "w"), indent=1, ensure_ascii=False)
+print(json.dumps({"pass": p, "text_docs": len(tl), "ok": sum(1 for x in tl if x["ok"]), "rows": [(x["title"], x.get("sections"), x["ok"]) for x in rows]}, ensure_ascii=False))
+sys.exit(0 if p else 7)

scrapers/mu_b1/verify_mu.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+"""Verify the staged MU mu_b1 pack. Exit 0 only if every check passes. Env MU_WORK.
+Checks: Hub tip unchanged since staging; schema (incl. metadata), codec and row-group layout equal to the tip; tip rows carried
+cell-identical; new ids unique (laws and articles, whole file); articles reference new laws; article_count matches; no Bills;
+bounds recorded; no padded dates; verbatim-slice substring gate (0 violations); no heading-only rows; no dominant article;
+no page furniture; every short Omitted/Repealed/Revoked/Deleted/dash body tagged repealed_placeholder; pii_scan (0 FAIL);
+rg + parquet secret scans; webmail check on new rows; redaction manifest without '@'; README YAML safe_load + text-quality
+section naming every DEGRADED item + licence paraphrase with the terms URL; scrapers bundle complete and self-contained
+(no absolute fleet paths, pinned requirements, how-to-run README, bundled robots_guard + br_waiting.sh, code record hashes);
+no published scrapers/ file of the tip overwritten; known_gaps complete; SHA256SUMS valid and complete.
+Secret patterns are assembled from fragments so this file never matches itself."""
+import hashlib, json, os, re, subprocess, sys, urllib.request
+from collections import Counter
+from pathlib import Path
+import pyarrow.parquet as pq, yaml
+HERE = Path(__file__).resolve().parent; sys.path.insert(0, str(HERE))
+from pii_scan_mu import scan
+import articles_mu as AM, classify_mu as CM, webmail_mu as WMU, split_mu as SM
+W = Path(os.environ.get("MU_WORK", ".")).resolve()
+S = json.load(open(W / "stage_summary.json")); P = W / "hf_mu_b1" / S["repo"].split("/")[1]; TD = W / "tip_stage" / S["parent"][:8]
+res, ok = {}, True
+def chk(name, cond, detail=None):
+    global ok
+    res[name] = {"ok": bool(cond), **({"detail": detail} if detail is not None else {})}; ok &= bool(cond)
+try:
+    live = json.load(urllib.request.urlopen(f"https://huggingface.co/api/datasets/{S['repo']}", timeout=60))["sha"]
+except Exception as e:
+    live = f"ERR {e}"[:120]
+chk("hub_tip_unchanged", live == S["parent"], {"parent": S["parent"], "live": live})
+def lay(p):
+    md = pq.ParquetFile(p).metadata; return (md.num_row_groups, md.row_group(0).column(0).compression)
+for name in ("laws", "articles"):
+    o, t = pq.read_table(P / f"data/{name}.parquet"), pq.read_table(TD / f"data/{name}.parquet")
+    chk(f"{name}_tip_prefix_identical", o.slice(0, t.num_rows).equals(t), {"tip_rows": t.num_rows, "out_rows": o.num_rows})
+    chk(f"{name}_schema_equal", o.schema.equals(t.schema, check_metadata=True))
+    chk(f"{name}_codec_rowgroups_equal", lay(P / f"data/{name}.parquet") == lay(TD / f"data/{name}.parquet"))
+L, A = pq.read_table(P / "data/laws.parquet").to_pylist(), pq.read_table(P / "data/articles.parquet").to_pylist()
+nt = S["tip_laws"]; new = L[nt:]; tip_ids = {r["id"] for r in L[:nt]}; nart = A[S["tip_articles"]:]
+chk("material_and_rows_ge_tip", len(new) >= 1 and len(L) >= nt, {"new_laws": len(new), "laws_rows": len(L)})
+chk("new_law_ids_unique_not_in_tip", len({r["id"] for r in new}) == len(new) and not ({r["id"] for r in new} & tip_ids))
+_dc = Counter(a["id"] for a in A); _dups = [k for k, v in _dc.items() if v > 1]
+_tipdup = [k for k in _dups if not k.startswith("mu-ago-")]
+chk("article_ids_unique_whole_file", not [k for k in _dups if k.startswith("mu-ago-")], {"new_batch_dups": [k for k in _dups if k.startswith("mu-ago-")][:5], "preexisting_tip_dup_ids_count": len(_tipdup), "note": "pre-existing tip duplicates are left unchanged (append-only)"})
+nid = {r["id"]: r for r in new}
+chk("new_articles_reference_new_laws", all(a["law_id"] in nid for a in nart))
+cnt = Counter(a["law_id"] for a in nart)
+chk("article_count_matches", all(cnt.get(i, 0) == r["article_count"] for i, r in nid.items()))
+chk("no_bill_titles", not [r["id"] for r in new if re.search(r"(?i)\bbill\b", r["title"])])
+chk("bounds_recorded", all('"bounds"' in r["metadata_json"] for r in new))
+chk("no_padded_dates", not [r["id"] for r in new if (r["date"] or "").endswith("-01-01") or (r["date_issued"] or "").endswith("-01-01")])
+chk("no_empty_articles", all(r["article_count"] >= 1 for r in new) and all((a["text"] or "").strip() for a in nart))
+byl = {}
+for a in nart: byl.setdefault(a["law_id"], []).append(a)
+sv = [v for lid, arts in byl.items() for v in AM.gate(nid[lid]["text"], arts)]
+chk("substring_gate_verbatim_slices", not sv, {"violations": len(sv), "first": sv[:5]})
+bs = Counter(json.loads(a["metadata_json"]).get("body_status") for a in nart)
+chk("no_heading_only_rows", bs.get("heading_only", 0) == 0, dict(bs))
+dom = [lid for lid, arts in byl.items() if AM.dominant(arts)]
+chk("no_dominant_article", not dom, {"laws": dom[:5]})
+furn = [r["id"] for r in new if re.search(r"(?m)^\s*\[\s*Issue\s+\d+\s*\]\s*$", r["text"]) or any(SM.MUFURN.match(l) for l in r["text"].splitlines())]
+chk("no_page_furniture", not furn, {"laws": furn[:5]})
+untag = []
+for a in nart:
+    md = json.loads(a["metadata_json"])
+    if md.get("body_status") == "body" and not md.get("whole_text_fallback") and not md.get("schedule") and len(a["text"]) < 200:
+        first = CM.NUM.sub("", a["text"].split("\n")[0]).strip(); rest = [l for l in a["text"].split("\n")[1:] if l.strip()]
+        if CM.PL.match(first) and not rest: untag.append(a["id"])
+chk("placeholders_tagged", not untag, {"untagged": untag[:5]})
+pii = scan([str(P / "data/laws.parquet"), str(P / "data/articles.parquet")])
+pn = [h for h in pii if h["level"] == "fail"]
+chk("pii_manifest_matches_scan", json.load(open(P / "manifests/mu_b1_pii_scan.json")) == {"new_fail": len(pn), "new_hits": pii})
+chk("pii_scan_new_rows_no_fail", not pn, {"new_fail": len(pn), "kinds": dict(Counter(h["kind"] for h in pn)), "new_warn": sum(1 for h in pii if h["level"] == "warn")})
+SEC = [r"AKIA" + r"[0-9A-Z]{16}", r"xox" + r"[baprs]-[0-9A-Za-z-]{10,}", r"s" + r"k-[A-Za-z0-9]{20,}", r"gh" + r"[pousr]_[A-Za-z0-9]{30,}",
+       r"h" + r"f_[A-Za-z0-9]{30,}", r"-----BEGIN [A-Z ]*PRIV" + r"ATE KEY-----", r"AI" + r"za[0-9A-Za-z_\-]{35}", r"gl" + r"pat-[0-9A-Za-z_\-]{20}"]
+rx = re.compile("|".join(SEC)); rg_hits = []
+for pat in SEC:
+    r = subprocess.run(["rg", "-c", "--no-messages", "-e", pat, str(P)], capture_output=True, text=True)
+    rg_hits += [l.rsplit(":", 1)[0] for l in r.stdout.splitlines() if l.strip()]
+pq_hits = {"new": 0, "inherited": 0}
+for rows, k0 in ((L, nt), (A, S["tip_articles"])):
+    for i, r in enumerate(rows):
+        for v in r.values():
+            if isinstance(v, str) and rx.search(v): pq_hits["new" if i >= k0 else "inherited"] += 1
+chk("secret_scan_rg_files", not [h for h in rg_hits if not h.endswith(".parquet")], {"files": sorted(set(rg_hits))})
+chk("secret_scan_parquet_new_rows", pq_hits["new"] == 0, pq_hits)
+WM2 = re.compile(r"[A-Za-z0-9._%+\-]+\s*@\s*(?:gmail|googlemail|yahoo|ymail|hotmail|outlook|live|msn|aol|icloud|gmx|protonmail|zoho|yandex)\b", re.I)
+wm = [r.get("id") for r in new + nart for v in r.values() if isinstance(v, str) and (WM2.search(v) or WMU.WEBMAIL_CHECK.search(v) or WMU.redact(v)[1])]
+chk("no_webmail_new_rows", not wm, {"rows": len(wm)})
+chk("redaction_manifest_no_at", "@" not in (P / "manifests/webmail_redactions.json").read_text())
+rd = (P / "README.md").read_text()
+try:
+    fm = yaml.safe_load(rd.split("---", 2)[1]); chk("readme_yaml_safe_load", isinstance(fm, dict) and "configs" in fm)
+except Exception as e:
+    chk("readme_yaml_safe_load", False, str(e)[:200])
+chk("readme_text_quality_section", "### OCR and text quality (batch mu_b1)" in rd and all(d["title"] in rd for d in S["degraded"]))
+chk("readme_licence_paraphrase_and_url", "termofuse.aspx" in rd and "Solicitor General" in rd and "LexisNexis" in rd)
+chk("readme_totals", f"{S['laws_rows']:,}" in rd and f"{S['articles_rows']:,}" in rd)
+sr = P / "scrapers/mu_b1/README.md"
+chk("scrapers_readme_how_to_run", sr.exists() and len(sr.read_text().splitlines()) >= 40 and "How to run" in sr.read_text() and "ipfs_mauritius_laws" in sr.read_text())
+tip_files = set(S["tip_files"]); pack_files = {str(f.relative_to(P)) for f in P.rglob("*") if f.is_file() and "__pycache__" not in f.parts}
+over = sorted(f for f in pack_files & tip_files if f.startswith("scrapers/"))
+chk("no_published_scrapers_overwritten", not over, {"overwritten": over})
+allowed_overwrite = {"data/laws.parquet", "data/articles.parquet", "README.md", "MANIFEST.md", "MANIFEST.json", "provenance/changes.json"}
+chk("only_expected_tip_files_changed", (pack_files & tip_files) <= allowed_overwrite, sorted(pack_files & tip_files))
+wsp = subprocess.run(["rg", "-l", "--no-messages", "/" + "workspace", str(P / "scrapers/mu_b1"), str(P / "scrapers/requirements.txt"), str(P / "manifests")], capture_output=True, text=True).stdout.split()
+chk("no_hardcoded_workspace_paths_in_bundle", not wsp, {"files": wsp})
+rq = (P / "scrapers/requirements.txt").read_text().splitlines()
+chk("requirements_pinned", all("==" in l for l in rq if l.strip() and not l.startswith("#")) and any(l.startswith("pyarrow==") for l in rq) and any(l.startswith("requests==") for l in rq))
+code = json.load(open(P / "manifests/mu_b1_code.json"))
+chk("code_record_matches_bundle", all(hashlib.sha256((P / "scrapers/mu_b1" / n).read_bytes()).hexdigest() == h for n, h in code["files"].items())
+    and set(code["files"]) == {f.name for f in (P / "scrapers/mu_b1").iterdir() if f.is_file()})
+imports = set()
+for f in (P / "scrapers/mu_b1").glob("*.py"):
+    for m in re.finditer(r"(?m)^\s*(?:from|import)\s+([A-Za-z_][A-Za-z0-9_]*)", f.read_text()): imports.add(m.group(1))
+local = {f.stem for f in (P / "scrapers/mu_b1").glob("*.py")}
+std = {"argparse","html","json","os","re","sys","threading","time","hashlib","urllib","subprocess","unicodedata","collections","datetime","pathlib","shutil","__future__","typing","dataclasses","fnmatch","socket","ssl","random","math","io","glob","signal","contextlib","functools","itertools","tempfile","traceback","errno","statistics","string","copy","warnings","logging","base64","email","http","gzip","csv","struct","fcntl","queue","textwrap","uuid","inspect","codecs","types","enum","abc","platform","stat","operator","locale","resource","shlex","zlib","bisect","heapq","secrets","weakref","pprint","difflib"}
+ext = {"requests","pyarrow","yaml","certifi","urllib3"}
+unk = sorted(i for i in imports if i not in local | std | ext)
+chk("bundle_self_contained_imports", not unk, {"unknown_imports": unk})
+kg = json.load(open(P / "manifests/known_gaps.json"))
+chk("known_gaps_complete", kg["whole_text_fallback_laws"]["count"] == S["whole_text_fallback"] and kg["heading_only_rows_dropped"]["count"] == S["heading_only_dropped"]
+    and kg["duplicate_drops"]["count"] == sum(v for k, v in S["drops"].items() if k.startswith("duplicate")))
+wt = {r["id"] for r in new if json.loads(r["metadata_json"]).get("whole_text_fallback")}
+chk("whole_text_laws_listed", wt == {i["law_id"] for i in kg["whole_text_fallback_laws"]["items"]})
+sums = [l.split("  ", 1) for l in (P / "SHA256SUMS").read_text().splitlines()]
+listed = {f for _, f in sums}; want = pack_files - {"SHA256SUMS"}
+chk("sha256sums_valid_and_complete", all(hashlib.sha256((P / f).read_bytes()).hexdigest() == h for h, f in sums) and want <= listed, {"listed": len(listed), "missing": sorted(want - listed)})
+for f in ("manifests/known_gaps.json", "manifests/changed_ids.json", "manifests/pii_scan_notes.md", "manifests/webmail_redactions.json", "manifests/mu_b1_code.json",
+          "manifests/mu_b1_summary.json", "manifests/mu_b1_drops.jsonl", "manifests/mu_b1_pii_scan.json", "scrapers/mu_b1/robots_guard.py", "scrapers/mu_b1/br_waiting.sh",
+          "scrapers/requirements.txt", "SHA256SUMS", "MANIFEST.md", "README.md"):
+    chk(f"present_{f}", (P / f).exists())
+print(json.dumps(res, indent=1)); print("VERIFY", "PASS" if ok else "FAIL")
+sys.exit(0 if ok else 1)

scrapers/mu_b1/webmail_mu.py

@@ -0,0 +1,39 @@
+"""Free-webmail redaction (from gh_fixb; mu_b1 adds a guard against prose like 'x at live'). Placeholder follows the GH lane convention: [redacted-webmail].
+Matches standard, typo-domain, truncated, line-split, spaced and missing-'@' forms of free-webmail addresses.
+Institutional/government addresses (any other domain) are left alone. Returns spans/categories only - never values."""
+import re
+PH='[redacted-webmail]'
+S=r'[ \t]*'                       # spaces around '@' / '.'
+WS=r'\s*'                         # allows a line break inside a split token
+LOCAL=r'[A-Za-z0-9._%+\-]+'
+STD=r'(?:gmail|googlemail|yahoo|ymail|hotmail|outlook|aol|icloud|live|msn)'
+TYPO=r'(?:gmial|gmai|gamil|g\.mail|y\.mail|yaho0*o?|yahooo+|yaho0o|yhoo|hotmial|hotmai|hotmal)'
+SPLIT=r'(?:g'+WS+r'mail|ya'+WS+r'hoo|hot'+WS+r'mail|y'+WS+r'mail)'
+TLD=r'(?:'+S+r'\.'+S+r'(?:co'+WS+r'\.'+WS+r'uk|c'+WS+r'om\b|com\b|co\b|c\b|fr\b|de\b|ca\b|net\b))?'
+AT=re.compile(r'(?<![A-Za-z0-9._%+\-])('+LOCAL+r')'+S+r'(?:@|\(at\)|\[at\]|\bat\b)'+S+r'('+STD+r'|'+TYPO+r'|'+SPLIT+r')(?![A-Za-z])('+TLD+r')',re.I)
+DOT=re.compile(r'\b(?:at|dot)\b',re.I)
+NOAT=re.compile(r'(?<![A-Za-z0-9._%+\-@])[A-Za-z0-9._%+\-]{3,}\.(?:gmail|yahoo|hotmail|ymail)\.(?:com|co\.uk)\b',re.I)
+WORDY=re.compile(r'(?<![A-Za-z0-9._%+\-])'+LOCAL+r'\s+at\s+(?:gmail|yahoo|hotmail|ymail)\s+dot\s+(?:com|co\s+dot\s+uk)\b',re.I)
+def classify(m):
+    s=m.group(0); dom=(m.group(2) or '').lower(); tld=m.group(3) or ''
+    if '\n' in s: return 'line_split'
+    if re.search(r'\s@|@\s',s): return 'spaced'
+    if not re.fullmatch(STD,dom,re.I): return 'typo_domain'
+    if not re.fullmatch(r'\.(?:com|co\.uk)',tld.replace(' ','') ,re.I): return 'truncated'
+    return 'standard'
+def redact(text):
+    """-> (new_text, [ {category, start, end, new_start} ]) offsets refer to the input text / output text."""
+    spans=[]
+    for m in AT.finditer(text):
+        if "@" not in m.group(0) and not (m.group(3) or "").strip(): continue  # mu_b1: bare 'x at live' prose is not an address
+        spans.append((m.start(),m.end(),classify(m)))
+    for rx,cat in ((NOAT,'missing_at'),(WORDY,'spaced_words')):
+        for m in rx.finditer(text):
+            if not any(a<m.end() and m.start()<b for a,b,_ in spans): spans.append((m.start(),m.end(),cat))
+    spans.sort(); out=[]; recs=[]; pos=0; shift=0
+    for a,b,c in spans:
+        out.append(text[pos:a]); ns=a+shift; out.append(PH); recs.append({'category':c,'start':a,'end':b,'new_start':ns,'new_end':ns+len(PH)})
+        shift+=len(PH)-(b-a); pos=b
+    out.append(text[pos:]); return ''.join(out),recs
+WEBMAIL_CHECK=re.compile(r'[A-Za-z0-9._%+\-]+\s*@\s*(?:gmail|googlemail|yahoo|ymail|hotmail|outlook|live|msn|aol|icloud|gmx|protonmail|zoho|yandex)\b'
+                         r'|[A-Za-z0-9._%+\-]+@(?:gmial|y\.mail|yaho0*o?|hotmial|ya\s*\n\s*hoo)\b',re.I)

scrapers/requirements.txt

@@ -0,0 +1,7 @@
+# Exact versions used to build mu_b1 (pip freeze of the libraries the scrapers import; Python 3.10+).
+certifi==2026.7.22
+pyarrow==25.0.1
+PyYAML==6.0.3
+requests==2.34.2
+urllib3==2.8.0
+# System tools (not pip): poppler-utils (pdftotext/pdfinfo/pdftoppm), tesseract 5 + eng tessdata, ripgrep (rg).