Datasets:

SlayerLab
/

polish-dynaword

@@ -911,3 +911,63 @@ quoted citizens' statements remain), near-dedup vs `dziennik_ustaw`/`eurlex`
 turns well (98.9% of the ASW pilot's audited corrected characters), but it is
 the pilot comparison that makes the reconstruction auditable — keep that step
 for future spoken sources.

 turns well (98.9% of the ASW pilot's audited corrected characters), but it is
 the pilot comparison that makes the reconstruction auditable — keep that step
 for future spoken sources.
+---
+## Studia BAS — Kancelaria Sejmu research & public-policy journal (2021–2025)
+**Investigated:** 2026-08-29
+**Verdict:** `ready` — official open-access transition under **CC BY 3.0 PL** starting with issue **2(66)/2021**; verified per-article license statements and clean born-digital PDF text layer.
+Quarterly peer-reviewed journal published by the **Biuro Analiz Sejmowych (BAS)** of the Chancellery of the Sejm (Kancelaria Sejmu). Focuses on public policy, socio-economic research, constitutional and EU law, public finance, and legislative commentary. Provides contemporary, formal academic/policy analysis prose — a critical register bridging official administrative/legal texts and general expository literature without being raw statutory legalese or web crawl.
+### Archive enumeration & fetch route — verified
+- **Archive URL:** `https://studiabas.sejm.gov.pl/journal.nsf/pubBAS.xsp?view=12&seria=4&lang=PL`
+- **Enumeration:** The Lotus Domino / XPages archive portal uses dynamic AJAX updates. Querying issues by year (2021–2025) requires parsing the initial `xspForm` state (`$$viewid`, `$$ajaxid`, `cbYear`) and submitting multipart POST requests.
+- **PDF Resolution:** Issue records point to download endpoints on `orka.sejm.gov.pl` (either direct issue PDF paths or the download-counting agent `LiczOpen?OpenAgent&<UNID>`).
+- **WAF / Network:** `studiabas.sejm.gov.pl` is fronted by Imperva WAF, requiring browser-like TLS handshakes (`curl_cffi` impersonating Chrome) for reliable programmatic querying and retrieval.
+### License evidence — verified cutoff from issue 2(66)/2021
+- **Historical cutoff:** Issues 1–65 (prior to 2/2021) were published under traditional all-rights-reserved copyright.
+- **Open-access grant:** Starting with issue **2(66)/2021** (issue 66), the journal officially transitioned to open access under **Creative Commons Attribution 3.0 Poland (CC BY 3.0 PL / `CC-BY-3.0-PL`)**.
+- **Dual-gate verification:** Ingestion enforces a hard issue boundary (`issue >= 66`) and additionally validates the presence of the explicit CC BY 3.0 PL statement inside every article PDF (*"Artykuł został udostępniony na licencji Creative Commons – Uznanie Autorstwa 3.0 Polska (CC BY 3.0 PL)"*). Issues or articles lacking this statement fail closed.
+### PDF characteristics, text extraction & non-OCR status
+- **Born-digital PDFs (`is_ocr: False`):** Whole-issue PDFs feature high-fidelity digital text layers, not scanned or OCR-derived text.
+- **Article segmentation:** Multi-article issue PDFs are sliced at article title pages identified via title font size (`max_size >= 12`), registered DOI (`10.31268/StudiaBAS.YYYY.NN`), and the in-PDF CC BY license block.
+- **Layout normalization:**
+  - Running headers (page numbering, journal title, ISSN `2082-0658`, `studiabas.sejm.gov.pl`) and author affiliation footnote blocks are stripped from the main body.
+  - PDF line-break hyphenation is reconstructed for Polish compounds (e.g. `przedsię-\nbiorców`, `rolno-\n-spożywczy`).
+  - Paragraph breaks are preserved and reconstructed using vertical spacing, indentation, and heading font shifts.
+- **Polish scope:** Ingestion extracts the Polish title, Polish abstract (*Streszczenie*), Polish keywords (*Słowa kluczowe*), and full Polish article body. Incidental English titles/abstracts (*Abstract*, *Keywords*) in dual-language front matter are excluded from the main text.
+### Observed yield (2021–2025)
+- **Extracted articles:** **115 articles** across issues 66 to 81 (2021–2025).
+- **Retained articles:** **112 articles** after dropping 3 entirely English-language articles.
+- **Token volume:** ~112 long-form scholarly articles yielding ~0.8–1.2M tokens of dense, high-register Polish analytical prose.
+### Author, affiliation & PII handling
+- **Scholarly attribution:** Lead and contributing author names and DOIs are preserved in document metadata (`author`, `doi`, `source_url`) as official academic attribution.
+- **PII scrubbing:** Author email addresses, ORCID identifiers (`orcid.org/0000-...`), phone numbers, and national identifiers (PESEL, NIP, REGON) appearing in contact blocks or bios are systematically scrubbed and replaced with stable `[PII]` tokens, preserving sentence syntax.
+### Inclusion rationale & quality/bias caveats
+- **Inclusion rationale:** High-quality, editorially reviewed policy research and academic discourse with unambiguous CC BY 3.0 PL licensing, permanent DOI provenance, and zero OCR noise. Fills a major gap in formal analytical Polish.
+- **Quality & bias caveats:**
+  - Institutional focus: Content is oriented toward state policy, parliamentary advisory topics, economics, and legal regulation.
+  - Complex formatting: Rare multi-column tables, statistical charts, or boxed exhibits in PDFs may yield minor layout artifacts or omitted figure captions.
+### Cross-source exact dedup — verified 2026-08-31
+- All 112 released `studia_bas` texts are internally unique.
+- Full byte-for-byte text comparison against 4,366,651 documents in all 20
+  other local Parquets found **0 exact-text matches**.
+- No `studia_bas` record required removal. A future rebuild of
+  `biblioteka_nauki` still needs cross-source dedup because its current upstream
+  catalogue exposes 105 of these articles even though the released local shard
+  does not contain them.

data/studia_bas/NOTICE.md ADDED Viewed

	@@ -0,0 +1,37 @@

+# Attribution and licensing notice
+The `studia_bas` source contains peer-reviewed articles from *Studia BAS*, the
+socioeconomic and public-policy journal published by the Bureau of Research
+(Biuro Analiz Sejmowych) at the Chancellery of the Sejm, taken from the
+[official journal archive](https://studiabas.sejm.gov.pl/journal.nsf/pubBAS.xsp?view=12&seria=4&lang=PL).
+Articles are published under the [Creative Commons Attribution 3.0
+Poland](https://creativecommons.org/licenses/by/3.0/pl/) license
+(`CC-BY-3.0-PL`). That license applies from issue 2(66)/2021 onward; issues
+1(1) through 1(65) are marked "Wszelkie prawa zastrzeżone" and are excluded
+from this source entirely. The evidence for the cutoff, together with the
+SHA-256 hash of every eligible issue PDF, is recorded in
+`studia_bas.license-evidence.json`.
+For every released DynaWord document:
+- the `author` column carries the article's author list, read from the PDF
+  title page;
+- `studia_bas.attribution.jsonl` preserves the article DOI, the recommended
+  attribution URL, the journal archive URL, the issue number, the filename and
+  SHA-256 of the issue PDF the text came from, the publisher, the license URL
+  and the modification notice — one row per Parquet row, in the same order;
+- the text was extracted from the text layer of the official issue PDF. Running
+  headers, page numbers, author affiliation/contact blocks, and terminal
+  bibliographies were removed, residual personal data was replaced with `[PII]`,
+  and PDF line wrapping was normalized.
+CC BY 3.0 PL requires attribution and an indication that changes were made.
+When redistributing or adapting these texts, name the author and the publisher
+(Kancelaria Sejmu, Biuro Analiz Sejmowych), link the license, and retain the
+modification notice above.
+Figures, tables, photographs and any third-party material reproduced inside the
+source PDFs may carry separate rights and are not covered by this notice. Only
+the extracted article text is redistributed here; the issue PDFs themselves are
+not.

data/studia_bas/studia_bas.attribution.jsonl ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:0c9f024da591ecea96aec4ee340570dc6177b4c551ad376a42ee09cef65f80ee
+size 98122

data/studia_bas/studia_bas.license-evidence.json ADDED Viewed

	@@ -0,0 +1,171 @@

+{
+  "source": "studia_bas",
+  "checked_at": "2026-08-29T16:18:15Z",
+  "license_spdx": "CC-BY-3.0-PL",
+  "license_name": "Creative Commons Uznanie Autorstwa 3.0 Polska (CC BY 3.0 PL)",
+  "license_legal_code_url": "https://creativecommons.org/licenses/by/3.0/pl/legalcode",
+  "scope_and_cutoff": {
+    "rule": "CC BY 3.0 PL applies starting at issue 2(66)/2021 and does not automatically cover earlier issues.",
+    "cutoff_issue": 66,
+    "cutoff_issue_string": "2(66)/2021",
+    "cutoff_year": 2021,
+    "earlier_issues_status": "Issues 1(1)/2009 through 1(65)/2021 were published under All rights reserved (Wszelkie prawa zastrzeżone by Kancelaria Sejmu) and are not licensed under Creative Commons; they are strictly excluded.",
+    "eligible_issues_count": 17,
+    "eligible_issue_numbers": [
+      66,
+      67,
+      68,
+      69,
+      70,
+      71,
+      72,
+      73,
+      74,
+      75,
+      76,
+      77,
+      78,
+      79,
+      80,
+      81,
+      82
+    ]
+  },
+  "direct_official_evidence": {
+    "publisher": "Kancelaria Sejmu RP",
+    "journal": "Studia BAS (e-ISSN: 2082-0658, p-ISSN: 2080-2404)",
+    "evidence_urls": {
+      "journal_home_pl": "https://studiabas.sejm.gov.pl/journal.nsf/pubBAS.xsp?view=1&seria=4&lang=PL",
+      "journal_home_en": "https://studiabas.sejm.gov.pl/journal.nsf/pubBAS.xsp?view=1&seria=4&lang=EN",
+      "author_instructions_pl": "https://studiabas.sejm.gov.pl/journal.nsf/pubBAS.xsp?view=5&seria=4&lang=PL",
+      "author_instructions_en": "https://studiabas.sejm.gov.pl/journal.nsf/pubBAS.xsp?view=5&seria=4&lang=EN",
+      "archive_url": "https://studiabas.sejm.gov.pl/journal.nsf/pubBAS.xsp?view=12&seria=4&lang=PL",
+      "license_legal_code": "https://creativecommons.org/licenses/by/3.0/pl/legalcode"
+    },
+    "observed_wording": {
+      "website_open_access_statement_pl": "Od numeru 2(66)2021 zawartość kwartalnika jest udostępniana na licencji Creative Commons – Uznanie Autorstwa 3.0 Polska (CC-BY 3.0 PL). Pozwala ona na natychmiastowy bezpłatny dostęp do wszystkich opublikowanych artykułów i umożliwia wszystkim użytkownikom czytanie, pobieranie, kopiowanie, rozpowszechnianie, drukowanie, przeszukiwanie, wykorzystywanie linków do pełnej treści artykułów, ich indeksowanie, używanie jako danych w oprogramowaniu oraz wykorzystywanie w każdym innym celu zgodnym z warunkami licencji i przepisami prawa.",
+      "website_open_access_statement_en": "Starting from No. 2(66)2021, “Studia BAS” is licensed under the Creative Commons Attribution 3.0 Poland License (CC-BY 3.0 PL). It allows for immediate free access to the work and permitting any user to read, download, copy, distribute, print, search, or link to the full texts of articles, crawl them for indexing, pass them as data to software, or use them for any other lawful purpose.",
+      "website_author_contract_terms_pl": "Po przyjęciu artykułu do publikacji autor podpisuje z Kancelarią Sejmu (KS) umowę o dzieło z przeniesieniem majątkowych praw autorskich oraz Oświadczenie o występowaniu albo o niewystępowaniu konfliktu interesów (odrębny dokument wymagany przez KS). W umowie autor m.in. wyraża zgodę, aby Kancelaria Sejmu udostępniała dzieło na licencji Creative Commons-Uznanie autorstwa 3.0 PL (CC-BY 3.0 PL).",
+      "website_author_contract_terms_en": "After acceptance of the article for publication the author signs a contract for specific work and the transfer of proprietary copyrights with the Chancellery of the Sejm, and submits Conflict of interest disclosure statement (separate document required by the Chancellery). The author consents that the Chancellery of Sejm makes the work available under the Creative Commons-Attribution 3.0 PL license (CC-BY 3.0 PL).",
+      "website_open_access_notice_en": "Studia BAS is an open access journal. Starting from No. 2(66)2021 it is is licensed under the CC BY 3.0 PL license.",
+      "pdf_issue_editorial_notice": "Zawartość czasopisma została udostępniona na licencji Creative Commons – Uznanie Autorstwa 3.0 Polska (CC BY 3.0 PL).",
+      "pdf_article_license_notice": "Artykuł został udostępniony na licencji Creative Commons – Uznanie Autorstwa 3.0 Polska (CC BY 3.0 PL).",
+      "pdf_pre_cutoff_copyright_notice": "Wszelkie prawa zastrzeżone. Żadna część ani całość opracowania nie może być bez zgody wydawcy – Kancelarii Sejmu – reprodukowana, użyta do innej publikacji oraz przechowywana w jakiejkolwiek bazie danych."
+    }
+  },
+  "corroborating_evidence": {
+    "doaj": {
+      "indexed": true,
+      "journal_url": "https://doaj.org/toc/2082-0658",
+      "api_search_url": "https://doaj.org/api/v2/search/journals/issn:2082-0658",
+      "oa_start_year": 2021,
+      "publisher": "Kancelaria Sejmu",
+      "author_retains_copyright": false,
+      "finding": "DOAJ independently confirms the 2021 open access start date and copyright transfer to publisher Kancelaria Sejmu which grants the open license."
+    }
+  },
+  "eligible_pdfs": [
+    {
+      "issue": 66,
+      "filename": "Studia_BAS_66.pdf",
+      "bytes": 4741995,
+      "sha256": "f318ff61f5f7ce4a6df408a73439884d11a185d50811c16c09a6254eeabf1185"
+    },
+    {
+      "issue": 67,
+      "filename": "Studia_BAS_67.pdf",
+      "bytes": 2932063,
+      "sha256": "6a65b4abc1abe005bcf6d83a010361648061bd15f90f2593a58afcb49912a6b0"
+    },
+    {
+      "issue": 68,
+      "filename": "Studia_BAS_68.pdf",
+      "bytes": 3138686,
+      "sha256": "dad27e0f21ae93c9a9218d8b8e529b90e5e33aebbcd7ed651ad214d293e19bc9"
+    },
+    {
+      "issue": 69,
+      "filename": "Studia_BAS_69.pdf",
+      "bytes": 2376821,
+      "sha256": "4f574d44fd97496975345dcc0fbc86903cfe57d446655b2c42bbe80402cb8e8d"
+    },
+    {
+      "issue": 70,
+      "filename": "Studia_BAS_70.pdf",
+      "bytes": 3267508,
+      "sha256": "4ba093eb43594c929cc62ba86f46ac0a285430b27022b1f434454835e19a048b"
+    },
+    {
+      "issue": 71,
+      "filename": "Studia_BAS_71.pdf",
+      "bytes": 2776345,
+      "sha256": "356f7305608d52b851805b330a7e6d24c3320171a9c70ed967989bcd384442f7"
+    },
+    {
+      "issue": 72,
+      "filename": "Studia_BAS_72.pdf",
+      "bytes": 2277688,
+      "sha256": "59bf48a26429c127b148922c264a93ecca6c4e53f1b0f29d5df67eec3021046f"
+    },
+    {
+      "issue": 73,
+      "filename": "Studia_BAS_73.pdf",
+      "bytes": 6191724,
+      "sha256": "38f278d82fd7a48a985633481cd9c10e023a07179d05a358874ae9f0c934b1f9"
+    },
+    {
+      "issue": 74,
+      "filename": "Studia_BAS_74.pdf",
+      "bytes": 4428291,
+      "sha256": "3af2bad701f679d844adc0d7a6cda5d0fe0ec94ec379f73d79e615d703c82aa8"
+    },
+    {
+      "issue": 75,
+      "filename": "Studia_BAS_75.pdf",
+      "bytes": 2481583,
+      "sha256": "ef60fc12a1821db384ec7ba4bdfc42db25f14b705d2f9dc4d547a242ee4f16a2"
+    },
+    {
+      "issue": 76,
+      "filename": "Studia_BAS_76.pdf",
+      "bytes": 5269351,
+      "sha256": "69b739b58bfab8de967aba9b02babede9f59dc319d6e84bdd17c57f30b17e627"
+    },
+    {
+      "issue": 77,
+      "filename": "Studia_BAS_77.pdf",
+      "bytes": 1795087,
+      "sha256": "320eb7df6b03b90d53095c9d08c56cfd9c3cfceb5e84ba0d919a53c8d4655027"
+    },
+    {
+      "issue": 78,
+      "filename": "Studia_BAS_78.pdf",
+      "bytes": 2027451,
+      "sha256": "16fbd7b70a1fb9f244669923ec2d0260c09d17a6000aa7bee7192d1f9d368910"
+    },
+    {
+      "issue": 79,
+      "filename": "Studia_BAS_79.pdf",
+      "bytes": 2272573,
+      "sha256": "aa1a3100f2ed46941c442bca6bc2ada828c3d90dc5017eae560cebc4c122443e"
+    },
+    {
+      "issue": 80,
+      "filename": "Studia_BAS_80.pdf",
+      "bytes": 1347696,
+      "sha256": "b7e0a95ea4ab0ae97aa8297d3ecf103f3a68b5e2ba777718e91d608ef7b38765"
+    },
+    {
+      "issue": 81,
+      "filename": "Studia_BAS_81.pdf",
+      "bytes": 2017390,
+      "sha256": "ef24bab005c1ab17f381d6c7e5c8a12a3dd77ca2daa0ce0dbd411206569d9d36"
+    },
+    {
+      "issue": 82,
+      "filename": "Studia_BAS_82.pdf",
+      "bytes": 2359571,
+      "sha256": "40426dad520e291370a8172b4da4275789f3fc91587fc306fe6580c9bd6fcf3e"
+    }
+  ]
+}

data/studia_bas/studia_bas.md ADDED Viewed

	@@ -0,0 +1,79 @@

+# studia_bas
+Peer-reviewed Polish articles from *Studia BAS*, the socioeconomic and
+public-policy journal of the Bureau of Research (Biuro Analiz Sejmowych) at the
+Chancellery of the Sejm. Each record is one article, extracted from the text
+layer of the official issue PDF.
+## Dataset description
+- **Original platform:** https://studiabas.sejm.gov.pl/journal.nsf/pubBAS.xsp?view=12&seria=4&lang=PL
+- **Publisher:** Kancelaria Sejmu, Biuro Analiz Sejmowych
+- **Domain:** academic, economics, social policy and public policy
+- **Language:** Polish (`pl`)
+- **License:** `CC-BY-3.0-PL` — https://creativecommons.org/licenses/by/3.0/pl/
+- **Created:** 2021-2025 (per article in the `created` column)
+- **Added:** 2026-07-19 (inherited from the global `ADDED` constant in
+  `src/sources.py`, which is what `build_dynaword.py` stamps; the shard is left
+  as the committed pipeline produces it rather than hand-restamped)
+## Statistics
+| read | kept | characters | tokens (`cl100k_base` proxy) | issues |
+|---:|---:|---:|---:|---:|
+| 115 | 112 | 6,089,085 | 2,256,009 | 17 |
+The released Parquet uses the canonical DynaWord schema:
+`id, text, source, added, created, token_count, license, author`
+Every retained article carries its author list in `author`, read from the PDF
+title page. Because the canonical schema has no column for it, the per-article
+DOI, attribution URL and source-PDF hash that CC BY attribution requires live in
+`studia_bas.attribution.jsonl`, one row per Parquet row, in the same order.
+## Provenance and Licensing
+- **Origin**: Official journal archive at https://studiabas.sejm.gov.pl/journal.nsf/pubBAS.xsp?view=12&seria=4&lang=PL
+- **License**: Creative Commons Attribution 3.0 Poland (CC BY 3.0 PL).
+- **License Evidence**: CC BY 3.0 PL applies from issue 2(66)/2021 onward. Issues 1(1) through 1(65) are "Wszelkie prawa zastrzeżone" and are strictly excluded. This is corroborated by the journal's own statement and by pl.wikipedia.org/wiki/Studia_BAS. Eligible range is issues 66-82 = 17 issues. All 17 source PDFs are present locally and their SHA-256 hashes and byte sizes were independently recomputed and matched 17/17 against `data/studia_bas/studia_bas.license-evidence.json`.
+- **Genre/Register**: Peer-reviewed socioeconomic and public-policy articles, academic register.
+- **Coverage**: COMPLETE for the eligible range. Cross-checked against Crossref (journal ISSN 2082-0658, 246 works). Crossref lists 132 DOIs for issues 66-82; the corpus has 115. The 17-record difference is fully explained: every one of those 17 DOIs has type 'journal-issue' (issue-level front matter, no title, no authors, no pages), not 'journal-article'. Zero journal-article records are missing, and zero corpus DOIs are absent from Crossref.
+- **Coverage Cutoff**: `2(82)/2025`. Crossref holds nothing above DOI 10.31268/StudiaBAS.2025.10; the whole 2025.11-2025.25 and 2026.x ranges return HTTP 404. Newest Crossref deposit is 2026-03-06, i.e. roughly a 9-month deposit lag, so later issues may exist without DOIs yet.
+## Collection and Filtering
+- Articles are extracted from the text layer of the official issue PDFs. They are split by DOI title pages.
+- **Normalization/Modification**:
+  - Running headers, page numbers, author affiliation/contact blocks, terminal
+    bibliographies, and ORCID values are excluded.
+  - Common PII (emails, national identifiers) is replaced with `[PII]` to retain sentence structure.
+  - PDF line wrapping is normalized without flattening paragraph breaks.
+- **Drops (Language Gate)**: 115 read -> 112 kept. The three language-gate drops are genuine English-language articles, correctly dropped because they contain insufficient Polish:
+  - DOI 10.31268/StudiaBAS.2021.26 ("The EU Fiscal Risk Matrix")
+  - DOI 10.31268/StudiaBAS.2022.08 ("Cultural and creative sectors in the COVID-19 pandemic crisis")
+  - DOI 10.31268/StudiaBAS.2025.08 ("Integration of electricity markets throughout the European Economic Area")
+## Argument for Inclusion
+This source adds high-quality, professional, and peer-reviewed academic texts in the domain of economics, social policy, and public policy, enriching the corpus with formal legal and socioeconomic Polish terminology.
+## Metadata Quality
+- **Record ids** are derived from the article DOI (`studia_bas_<year>_<ordinal>`) and are stable across rebuilds (`preserve_id`).
+- **Authors** are read from the PDF title page, not from any metadata service. All 112 released author lists were cross-checked against Crossref: 108 match exactly, and none of the 4 differences is an extraction error. Three are errors in Crossref itself, where the PDF is correct ("Dorora"/"Dorota" Wyszkowska in 10.31268/StudiaBAS.2021.36, "Maciej N."/"Maciej J." Nowak in 10.31268/StudiaBAS.2023.02, and a dropped middle initial in 10.31268/StudiaBAS.2024.02); the fourth, 10.31268/StudiaBAS.2021.23, is a Crossref record that carries no author field at all. Co-authors are delimited by the affiliation markers the journal prints on the title page rather than by line spacing, because the journal sets a wrapped name and a following co-author at the same pitch; `src/test_studia_bas_contract.py` pins both that rule and the case of an author list running past the ordinary title-page band.
+- **PII audit**: `src/audit_studia_bas.py` finds zero emails, ORCIDs, PESEL,
+  NIP or REGON values across all 115 extracted records. Run
+  `src/report_studia_bas_audit.py --corpus <intermediate.jsonl>` to reproduce
+  it. The report also lists advisory extraction-quality heuristics; those
+  matchers are deliberately broad and fire on ordinary inline references, so
+  they do not fail the audit.
+## PII scrubber and NERGAL gate
+Scrubber that ran: `scrub_pii()` in `src/fetch_studia_bas.py` — regex pass over
+the extracted text (e-mail, ORCID, labelled PESEL/NIP/REGON, labelled phone ->
+`[PII]`), plus structural exclusion of author-affiliation/contact blocks and
+ORCID values at extraction time. This is **not**
+[SlayerLab/NERGAL](https://huggingface.co/SlayerLab/NERGAL); per AGENTS.md the
+shard must be re-run through NERGAL before it is admitted to a release (quoted
+case material and third-party names can survive any regex pass). Merge with
+`release: None` is fine meanwhile. The independent audit above (0 structured
+residuals over all 115 records) is evidence for the current build, not a
+substitute for the model-based pass.

data/studia_bas/studia_bas.parquet ADDED Viewed

	@@ -0,0 +1,3 @@

+version https://git-lfs.github.com/spec/v1
+oid sha256:cdcafd5bbda9c053abd4a4286181ca44dd8c16b556ba33232a18f81d218be1c7
+size 2362278

data/studia_bas/studia_bas.stats.json ADDED Viewed

	@@ -0,0 +1,16 @@

+{
+  "read": 115,
+  "kept": 112,
+  "drop_short": 0,
+  "drop_lang": 3,
+  "drop_dup": 0,
+  "drop_ocr": 0,
+  "chars": 6089085,
+  "tokens": 2256009,
+  "licenses": {
+    "CC-BY-3.0-PL": 112
+  },
+  "authors_with_value": 112,
+  "secs": 3.1,
+  "license": "CC-BY-3.0-PL"
+}

src/audit_studia_bas.py ADDED Viewed

	@@ -0,0 +1,79 @@

+import json
+import re
+from pathlib import Path
+from typing import Dict, Any, List
+EMAIL_RE = re.compile(r"(?i)[a-z0-9._%+-]+\s*@\s*[a-z0-9.-]+\s*\.\s*[a-z]{2,}")
+ORCID_RE = re.compile(r"(?i)\b(?:0\s*0\s*0\s*[0-3])\s*-\s*(?:\d\s*){4}\s*-\s*(?:\d\s*){4}\s*-\s*(?:\d\s*){3}[\dX]\b")
+PHONE_RE = re.compile(r"(?i)\btel\.?\s*:?\s*(?:\d\s*){9,}")
+PESEL_RE = re.compile(r"(?i)\bpesel\b\s*:?\s*(?:\d[\s-]*){11}\b")
+NIP_RE = re.compile(r"(?i)\bnip\b\s*:?\s*(?:\d[\s-]*){10}\b")
+REGON_RE = re.compile(r"(?i)\bregon\b\s*:?\s*(?:(?:\d[\s-]*){9}|(?:\d[\s-]*){14})\b")
+AFFILIATION_RE = re.compile(r"(?i)\b(uniwersytet|wydział|instytut|katedra|mgr inż|dr hab|prof\.)\b")
+NAV_HEADER_RE = re.compile(r"(?i)\bstudia bas\b|\bnr \d+\(\d+\)")
+HYPHEN_RE = re.compile(r"\b\w+-\s+[a-ząćęłńóśźż]\w+\b")
+REQUIRED_KEYS = {"id", "text", "source", "created", "license", "author", "doi", "source_url", "issue_url", "issue", "license_url"}
+def get_context(text, match):
+    if not match: return ""
+    s = max(0, match.start() - 40)
+    e = min(len(text), match.end() + 40)
+    snippet = text[s:e]
+    redacted = snippet[:match.start()-s] + "[REDACTED]" + snippet[match.end()-s:]
+    return redacted.replace('\n', ' ')
+def audit_record(record: Dict[str, Any], seen_ids: set, seen_texts: set) -> Dict[str, List[str]]:
+    issues = {}
+    text = record.get("text", "")
+    author = record.get("author", "")
+    doc_id = record.get("id", "")
+    # Missing metadata
+    if not all(k in record for k in REQUIRED_KEYS):
+        issues["malformed_metadata"] = ["Missing keys"]
+    if not author.strip():
+        issues["empty_author"] = ["Empty author field"]
+    if doc_id in seen_ids:
+        issues["duplicate_id"] = [f"ID: {doc_id}"]
+    seen_ids.add(doc_id)
+    if text in seen_texts:
+        issues["duplicate_text"] = ["Duplicate text block"]
+    seen_texts.add(text)
+    for issue_name, regex in [
+        ("residual_email", EMAIL_RE),
+        ("orcid_found", ORCID_RE),
+        ("phone_number", PHONE_RE),
+        ("pesel", PESEL_RE),
+        ("nip", NIP_RE),
+        ("regon", REGON_RE),
+        ("affiliation_block", AFFILIATION_RE),
+        ("navigation_header", NAV_HEADER_RE),
+        ("suspicious_hyphenation", HYPHEN_RE),
+    ]:
+        matches = list(regex.finditer(text))
+        if matches:
+            issues[issue_name] = [get_context(text, m) for m in matches[:2]]
+    return issues
+def audit_corpus(path: Path) -> Dict[str, Dict[str, List[str]]]:
+    results = {}
+    seen_ids = set()
+    seen_texts = set()
+    with open(path, 'r', encoding='utf-8') as f:
+        for line in f:
+            if not line.strip():
+                continue
+            record = json.loads(line)
+            doc_id = record.get("id", "UNKNOWN")
+            issues = audit_record(record, seen_ids, seen_texts)
+            if issues:
+                results[doc_id] = issues
+    return results

src/fetch_studia_bas.py ADDED Viewed

	@@ -0,0 +1,869 @@

+#!/usr/bin/env python3
+"""Extract CC-BY Studia BAS articles from official issue PDFs.
+The official archive publishes whole issues as text-layer PDFs.  This source
+extractor splits each issue at article title pages, removes running headers and
+author-affiliation blocks, normalizes PDF line wrapping, scrubs common PII and
+writes one JSONL record per article.  ``build_dynaword.py`` performs the
+canonical token count and Parquet build afterwards.
+PoC using an existing, reproducibly downloaded issue cache::
+    python3 src/fetch_studia_bas.py \
+      --pdf-dir D:/projects/open-charts/out/studiabas/pdf \
+      --issues 77 --sample 5 --out artifacts/studia_bas_sample.jsonl
+Only issue 66 (2/2021) and later are accepted because the journal's CC BY 3.0
+Poland grant starts there.  The license line is also verified inside every PDF;
+the issue number alone is never treated as sufficient evidence.
+"""
+from __future__ import annotations
+import argparse
+import functools
+import html as html_module
+import json
+import re
+import shutil
+import subprocess
+import tempfile
+import time
+import unicodedata
+import urllib.parse
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, Sequence
+SOURCE = "studia_bas"
+LICENSE = "CC-BY-3.0-PL"
+CC_BY_URL = "https://creativecommons.org/licenses/by/3.0/pl/"
+MIN_LICENSED_ISSUE = 66
+BASE = "https://studiabas.sejm.gov.pl"
+ARCHIVE_URL = BASE + "/journal.nsf/pubBAS.xsp?view=12&seria=4&lang=PL"
+ORKA = "https://orka.sejm.gov.pl"
+_DOI_RE = re.compile(r"(?:https?://(?:dx\.)?doi\.org/)?(10\.31268/StudiaBAS\.(\d{4})\.([0-9]+(?:\.[0-9]+)*))", re.I)
+_ISSUE_RE = re.compile(r"(?:Studia[_\s-]*BAS[_\s-]*|sb)(\d{1,3})", re.I)
+_ISSUE_YEAR_RE = re.compile(r"\b\d\((\d{2,3})\)\s*((?:19|20)\d{2})\b")
+_LICENSE_RE = re.compile(
+    r"Creative\s+Commons.{0,100}(?:Uznanie\s+Autorstwa|CC\s*BY).{0,40}3\.0.{0,20}(?:Polska|PL)",
+    re.I | re.S,
+)
+_MARKER_RE = re.compile(r"[*†‡]+")
+_MARKER_END_RE = re.compile(r"[*†‡]+\s*$")
+_EMAIL_RE = re.compile(r"(?<![\w.+-])[\w.+-]+@[\w.-]+\.[A-Za-z]{2,}(?![\w.-])")
+_ORCID_RE = re.compile(
+    r"(?i)(?:(?:https?\s*:\s*/\s*/\s*)?orcid\s*\.\s*org\s*/\s*|ORCID\s*:?\s*)?"
+    r"\b\d{4}-\d{4}-\d{4}-[\dX]{4}\b"
+)
+_PHONE_RE = re.compile(
+    r"(?i)(?<!\w)(?:tel(?:efon)?\.?\s*:?\s*|\+48[\s.-]*)(?:\d[\s.-]*){9}(?!\d)"
+)
+_PESEL_RE = re.compile(r"(?i)PESEL\s*:?\s*\d{11}\b")
+_NIP_RE = re.compile(r"(?i)NIP\s*:?\s*\d{3}[- ]?\d{3}[- ]?\d{2}[- ]?\d{2}\b")
+_REGON_RE = re.compile(r"(?i)REGON\s*:?\s*(?:\d{9}|\d{14})\b")
+_CONTROL_RE = re.compile(r"[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]")
+_ROW_RE = re.compile(r"<tr\b[^>]*>(.*?)</tr>", re.I | re.S)
+_CELL_RE = re.compile(r"<t[dh]\b[^>]*>(.*?)</t[dh]>", re.I | re.S)
+_TAG_RE = re.compile(r"<[^>]+>")
+_DOCID_RE = re.compile(r"documentId=([0-9A-Fa-f]{32})")
+_PDF_RE = re.compile(r'href=["\']([^"\']*?\.pdf)["\']', re.I)
+_AGENT_RE = re.compile(
+    r'href=["\']([^"\']*LiczOpen\?OpenAgent&amp;([0-9A-Fa-f]{32})[^"\']*)["\']', re.I
+)
+_VIEWID_RE = re.compile(r'name="\$\$viewid"[^>]*value="([^"]+)"')
+_PANEL_RE = re.compile(r'id="([^"]*:rok)"')
+_COMBO_RE = re.compile(r'name="([^"]*cbYear)"')
+_FORM_RE = re.compile(r'<form[^>]*id="([^"]+)"[^>]*class="xspForm"', re.I)
+_BIBLIOGRAPHY_HEADING_RE = re.compile(r"Bibliografia|References|Bibiliografia", re.I)
+_APPENDIX_HEADING_RE = re.compile(r"^(Załącznik|Aneks|Appendix)\b", re.I)
+@dataclass(frozen=True)
+class ArchiveIssue:
+    year: int
+    number: str
+    title: str
+    editor: str
+    document_id: str
+    @property
+    def url(self) -> str:
+        return f"{BASE}/journal.nsf/pubBAS.xsp?documentId={self.document_id}&lang=PL"
+@dataclass(frozen=True)
+class Block:
+    """Text block reduced to the layout signals needed by the extractor."""
+    text: str
+    x0: float
+    y0: float
+    x1: float
+    y1: float
+    min_size: float
+    max_size: float
+    lines: tuple[str, ...] = ()
+    title_text: str = ""
+    author_text: str = ""
+    abstract_text: str = ""
+def _html_text(fragment: str) -> str:
+    return " ".join(html_module.unescape(_TAG_RE.sub(" ", fragment)).replace("\xa0", " ").split())
+def parse_archive_rows(fragment: str, year: int) -> list[ArchiveIssue]:
+    """Parse the HTML fragment returned by the XPages year refresh."""
+    issues: list[ArchiveIssue] = []
+    seen: set[str] = set()
+    for row in _ROW_RE.findall(fragment):
+        found = _DOCID_RE.search(row)
+        if not found:
+            continue
+        document_id = found.group(1).upper()
+        if document_id in seen:
+            continue
+        seen.add(document_id)
+        cells = [_html_text(cell) for cell in _CELL_RE.findall(row)]
+        cells += [""] * (3 - len(cells))
+        parenthesized = re.search(r"\((\d{1,3})\)", cells[0])
+        plain = re.search(r"\d{1,3}", cells[0])
+        number = parenthesized.group(1) if parenthesized else (plain.group(0) if plain else "")
+        issues.append(ArchiveIssue(year, number, cells[2], cells[1], document_id))
+    return issues
+def find_issue_pdf_link(page: str, document_id: str) -> str | None:
+    """Resolve a direct PDF or the issue-specific download-counting agent."""
+    for href in _PDF_RE.findall(page):
+        url = html_module.unescape(href)
+        if "/xPDF/" in url:
+            continue
+        return ORKA + url if url.startswith("/") else url
+    for href, unid in _AGENT_RE.findall(page):
+        if unid.upper() != document_id.upper():
+            continue
+        url = html_module.unescape(href)
+        return ORKA + url if url.startswith("/") else url
+    return None
+def normalize_pdf_text(value: str) -> str:
+    """Normalize Unicode and whitespace without flattening paragraph breaks."""
+    value = unicodedata.normalize("NFKC", value)
+    value = value.replace("\u00ad", "").replace("\u200b", "")
+    value = re.sub(r"[\u00a0\u2000-\u200a\u202f\u205f\u3000]", " ", value)
+    value = _CONTROL_RE.sub("", value)
+    value = value.replace("…", "...")
+    value = value.replace("„", '"').replace("”", '"').replace("“", '"')
+    value = value.replace("–", "-").replace("—", "-")
+    # PDF line wrapping: hard hyphens repeat ("rolno-\n-spożywczy"), soft hyphens don't ("przedsię-\nbiorców").
+    value = re.sub(r"(?<=\w)-\s*\n\s*-(?=\w)", "-", value)
+    value = re.sub(r"(?<=\w)-\s*\n\s*(?=[a-ząćęłńóśźż])", "", value)
+    value = re.sub(r"[ \t]+", " ", value)
+    value = re.sub(r" *\n *", "\n", value)
+    value = re.sub(r"\n{3,}", "\n\n", value)
+    return value.strip()
+def scrub_pii(value: str) -> str:
+    """Replace contact and national identifiers while retaining sentence shape."""
+    for pattern in (_EMAIL_RE, _ORCID_RE, _PESEL_RE, _NIP_RE, _REGON_RE, _PHONE_RE):
+        value = pattern.sub("[PII]", value)
+    return normalize_pdf_text(value)
+def _from_pymupdf(raw: dict) -> Block | None:
+    lines = raw.get("lines")
+    if not lines:
+        return None
+    line_texts: list[str] = []
+    title_lines: list[str] = []
+    author_lines: list[str] = []
+    abstract_lines: list[str] = []
+    sizes: list[float] = []
+    for line in lines:
+        spans = line.get("spans", [])
+        text = "".join(str(span.get("text", "")) for span in spans)
+        if text.strip():
+            line_texts.append(text.strip())
+        title = "".join(str(span.get("text", "")) for span in spans if float(span.get("size", 0.0)) >= 12)
+        author = "".join(
+            str(span.get("text", ""))
+            for span in spans
+            if 8.8 <= float(span.get("size", 0.0)) <= 10.5
+        )
+        if title.strip():
+            title_lines.append(title.strip())
+        if author.strip():
+            author_lines.append(author.strip())
+        if text.strip() and spans and not any(int(span.get("flags", 0)) & 16 for span in spans):
+            abstract_lines.append(text.strip())
+        sizes.extend(float(span.get("size", 0.0)) for span in spans)
+    text = "\n".join(line_texts).strip()
+    if not text or not sizes:
+        return None
+    x0, y0, x1, y1 = map(float, raw["bbox"])
+    return Block(
+        text,
+        x0,
+        y0,
+        x1,
+        y1,
+        min(sizes),
+        max(sizes),
+        tuple(line_texts),
+        "\n".join(title_lines),
+        "\n".join(author_lines),
+        "\n".join(abstract_lines),
+    )
+def pdf_pages(path: Path) -> list[list[Block]]:
+    """Read the text layer; scanned/image-only issues fail closed."""
+    try:
+        import pymupdf
+    except ImportError as exc:  # pragma: no cover - environment-specific
+        raise RuntimeError("Studia BAS extraction requires pymupdf: pip install pymupdf") from exc
+    document = pymupdf.open(path)
+    pages: list[list[Block]] = []
+    for page in document:
+        blocks = [block for raw in page.get_text("dict")["blocks"] if (block := _from_pymupdf(raw))]
+        pages.append(sorted(blocks, key=lambda item: (item.y0, item.x0)))
+    if not pages or sum(bool(page) for page in pages) < len(pages) * 0.8:
+        raise ValueError(f"{path} has too many pages without a usable text layer")
+    return pages
+def _page_text(page: Sequence[Block]) -> str:
+    return "\n".join(block.text for block in page)
+def article_start_indexes(pages: Sequence[Sequence[Block]]) -> list[int]:
+    """Find article title pages, rejecting incidental DOI citations."""
+    starts: list[int] = []
+    for index, page in enumerate(pages):
+        text = _page_text(page)
+        has_title = any(block.max_size >= 12 and 70 <= block.y0 <= 250 for block in page)
+        if has_title and _DOI_RE.search(text) and _LICENSE_RE.search(text):
+            starts.append(index)
+    return starts
+def _author_lines(value: str) -> list[tuple[str, bool]]:
+    """Author lines, each flagged with the affiliation marker that closes a name.
+    Studia BAS prints one asterisk run per co-author, so a marked line ends an
+    author and an unmarked line below it is the wrapped remainder of that name.
+    Markers are stripped from the name itself; only their position is a signal.
+    """
+    value = re.sub(r"^\s*\d+\s*", "", value, flags=re.MULTILINE)
+    lines: list[tuple[str, bool]] = []
+    for line in normalize_pdf_text(value).splitlines():
+        marked = bool(_MARKER_END_RE.search(line))
+        line = " ".join(_MARKER_RE.sub("", line).split())
+        if line:
+            lines.append((line, marked))
+    return lines
+def _join_author(previous: str, line: str) -> str:
+    """Append a wrapped continuation line, healing the hyphen the wrap repeated."""
+    if previous.endswith("-"):
+        return previous + line.lstrip("-")
+    return previous + " " + line
+def _front_matter(page: Sequence[Block]) -> dict[str, object]:
+    title_candidates = [
+        block
+        for block in page
+        if (block.title_text or block.max_size >= 12) and 70 <= block.y0 <= 250
+    ]
+    if not title_candidates:
+        raise ValueError("article page has no large Polish title block")
+    title_candidates.sort(key=lambda block: (block.y0, block.x0))
+    title = normalize_pdf_text(
+        "\n".join(block.title_text or block.text for block in title_candidates)
+    ).replace("\n", " ")
+    title_block = title_candidates[0]
+    # The author band ends at 155 in every ordinary layout, but a long author
+    # list simply keeps running down the page, so follow it while the blocks stay
+    # contiguous and keep the same author typography.
+    author_values: list[str] = []
+    author_blocks: list[Block] = []
+    for block in page:
+        if block.y0 < 55:
+            continue
+        geometric = 8.8 <= block.max_size <= 10.5 and block.x0 < title_block.x0 - 5
+        if block.y0 > 155:
+            previous = author_blocks[-1] if author_blocks else None
+            if previous is None or not geometric or not 0 <= block.y0 - previous.y1 <= 4:
+                continue
+            if not (8.8 <= previous.max_size <= 10.5 and previous.x0 < title_block.x0 - 5):
+                continue
+        value = block.author_text or (block.text if geometric else "")
+        if value:
+            author_values.append(value)
+            author_blocks.append(block)
+    # Line pitch cannot tell a wrapped name from the next co-author: the journal
+    # sets some title pages at 12pt leading and others at 14.9pt, so both look
+    # alike.  The affiliation marker can, and it is present whenever there is
+    # more than one author to tell apart.
+    lines = [pair for value in author_values for pair in _author_lines(value)]
+    authors: list[str] = []
+    if any(marked for _, marked in lines):
+        closed = True
+        for line, marked in lines:
+            if authors and not closed:
+                authors[-1] = _join_author(authors[-1], line)
+            else:
+                authors.append(line)
+            closed = marked
+    else:
+        # No marker means nothing delimits the names, which is what a sole author
+        # looks like: a name wrapped over one or two lines ("Agnieszka Paulina" /
+        # "Smolenska").  Only fall back to guessing per line if the join is too
+        # long to be one person's name.
+        joined = functools.reduce(_join_author, [line for line, _ in lines], "").strip()
+        if len(joined.split()) <= 4:
+            authors = [joined] if joined else []
+        else:
+            for line, _ in lines:
+                if authors and authors[-1].endswith("-"):
+                    authors[-1] = _join_author(authors[-1], line)
+                elif authors and len(line.split()) == 1 and len(authors[-1].split()) == 1:
+                    authors[-1] = _join_author(authors[-1], line)
+                else:
+                    authors.append(line)
+    authors = [author for author in authors if author and len(author.split()) <= 8]
+    doi_match = _DOI_RE.search(_page_text(page))
+    if not doi_match:
+        raise ValueError("article page has no Studia BAS DOI")
+    doi = doi_match.group(1)
+    # DOI suffix format mapping: 2024.03 -> 03, 2024.1.1 -> 01_01.
+    # We zero-pad each part to 2 digits to ensure deterministic sorting
+    # and prevent collisions across issues that reset article numbering.
+    ordinal_raw = doi_match.group(3)
+    ordinal = "_".join(f"{int(p):02d}" for p in ordinal_raw.split("."))
+    doi_blocks = [block for block in page if _DOI_RE.search(block.text)]
+    doi_top = min(block.y0 for block in doi_blocks)
+    title_bottom = max(block.y1 for block in title_candidates)
+    abstract_parts: list[str] = []
+    for block in page:
+        if block.y0 < title_bottom - 1 or block.y0 >= doi_top or block.max_size > 8.5:
+            continue
+        value = block.abstract_text
+        if not value:
+            lines = list(block.lines) if block.lines else block.text.splitlines()
+            value = "\n".join(lines[1:]) if len(lines) >= 2 else ""
+        if value and not value.lstrip().startswith(("DOI", "Słowa", "Keywords")):
+            abstract_parts.append(value)
+    abstract = normalize_pdf_text("\n".join(abstract_parts)).replace("\n", " ")
+    keywords = ""
+    for block in page:
+        compact = normalize_pdf_text(block.text).replace("\n", " ")
+        if compact.lower().startswith("słowa kluczowe"):
+            keywords = re.sub(r"(?i)^słowa kluczowe\s*", "", compact).strip()
+            break
+    license_blocks = [block for block in page if _LICENSE_RE.search(block.text)]
+    if not license_blocks:
+        raise ValueError("article page lacks its CC BY 3.0 PL statement")
+    license_bottom = max(block.y1 for block in license_blocks)
+    return {
+        "title": title,
+        "authors": authors,
+        "doi": doi,
+        "year": int(doi_match.group(2)),
+        "ordinal": ordinal,
+        "abstract": abstract,
+        "keywords": keywords,
+        "license_bottom": license_bottom,
+    }
+def _content_blocks(pages: Sequence[Sequence[Block]], license_bottom: float) -> list[Block]:
+    content: list[Block] = []
+    for page_index, page in enumerate(pages):
+        for block in page:
+            if block.y0 < 50:  # running header/page number
+                continue
+            if page_index == 0 and block.y0 <= license_bottom:
+                continue
+            content.append(block)
+    return content
+def _blocks_to_text(blocks: Sequence[Block]) -> str:
+    paragraphs: list[str] = []
+    current = ""
+    previous: Block | None = None
+    for block in blocks:
+        value = normalize_pdf_text(block.text)
+        if not value:
+            continue
+        heading = block.max_size >= 10.3 and len(value) < 180
+        gap = block.y0 - previous.y1 if previous is not None else 99.0
+        indented = block.x0 >= 65 and previous is not None
+        font_change = previous is not None and abs(block.max_size - previous.max_size) >= 1.0
+        new_paragraph = heading or previous is None or gap > 4.5 or indented or font_change
+        if new_paragraph and current:
+            paragraphs.append(normalize_pdf_text(current))
+            current = ""
+        if heading:
+            paragraphs.append(value.replace("\n", " "))
+        else:
+            piece = value.replace("\n", " ")
+            if current.endswith("-") and re.match(r"^-?[a-ząćęłńóśźż]", piece):
+                current = current[:-1] + piece.lstrip("-")
+            else:
+                current = f"{current} {piece}".strip()
+        previous = block
+    if current:
+        paragraphs.append(normalize_pdf_text(current))
+    return "\n\n".join(paragraph for paragraph in paragraphs if paragraph)
+def remove_terminal_bibliography(text: str) -> str:
+    """Remove terminal bibliography section while restoring any substantive appendix."""
+    body_parts = text.split("\n\n")
+    bib_idx = -1
+    for i in reversed(range(len(body_parts))):
+        if _BIBLIOGRAPHY_HEADING_RE.fullmatch(body_parts[i].strip()):
+            bib_idx = i
+            break
+    if bib_idx != -1:
+        end_idx = len(body_parts)
+        for i in range(bib_idx + 1, len(body_parts)):
+            if _APPENDIX_HEADING_RE.match(body_parts[i].strip()) and len(body_parts[i]) < 150:
+                end_idx = i
+                break
+        body_parts = body_parts[:bib_idx] + body_parts[end_idx:]
+        return "\n\n".join(body_parts)
+    return text
+def extract_article(
+    pages: Sequence[Sequence[Block]],
+    *,
+    issue_number: str,
+    year: int,
+    issue_url: str = "",
+) -> dict[str, object]:
+    """Convert one already-sliced article to a provenance-rich JSONL record."""
+    if not pages:
+        raise ValueError("article has no pages")
+    meta = _front_matter(pages[0])
+    if int(meta["year"]) != int(year):
+        raise ValueError(f"issue year {year} disagrees with DOI year {meta['year']}")
+    body = _blocks_to_text(_content_blocks(pages, float(meta["license_bottom"])))
+    body = remove_terminal_bibliography(body)
+    parts = [str(meta["title"])]
+    if meta["abstract"]:
+        parts.extend(["Streszczenie", str(meta["abstract"])])
+    if meta["keywords"]:
+        parts.extend(["Słowa kluczowe", str(meta["keywords"])])
+    parts.append(body)
+    text = scrub_pii("\n\n".join(part for part in parts if part).strip())
+    doi = str(meta["doi"])
+    ordinal = str(meta["ordinal"])
+    return {
+        "id": f"{SOURCE}_{year}_{ordinal}",
+        "text": text,
+        "source": SOURCE,
+        "created": str(year),
+        "license": LICENSE,
+        "author": "; ".join(str(author) for author in meta["authors"]),
+        "doi": doi,
+        "source_url": f"https://doi.org/{doi}",
+        "issue_url": issue_url,
+        "issue": str(issue_number),
+        "license_url": CC_BY_URL,
+    }
+def issue_metadata(path: Path, pages: Sequence[Sequence[Block]]) -> tuple[str, int]:
+    number_match = _ISSUE_RE.search(path.stem)
+    front = "\n".join(_page_text(page) for page in pages[:8])
+    issue_year = _ISSUE_YEAR_RE.search(front)
+    number = number_match.group(1) if number_match else (issue_year.group(1) if issue_year else "")
+    year = int(issue_year.group(2)) if issue_year else 0
+    if not number or not year:
+        raise ValueError(f"cannot infer issue/year from {path}")
+    if int(number) < MIN_LICENSED_ISSUE:
+        raise ValueError(f"issue {number} predates the CC BY corpus boundary (66)")
+    if not _LICENSE_RE.search(front):
+        raise ValueError(f"issue {number} does not expose the expected CC BY 3.0 PL statement")
+    return number, year
+def extract_issue(path: Path, issue_url: str = "") -> list[dict[str, object]]:
+    pages = pdf_pages(path)
+    issue_number, year = issue_metadata(path, pages)
+    starts = article_start_indexes(pages)
+    if not starts:
+        raise ValueError(f"no article title pages found in {path}")
+    records: list[dict[str, object]] = []
+    for position, start in enumerate(starts):
+        end = starts[position + 1] if position + 1 < len(starts) else len(pages)
+        records.append(
+            extract_article(
+                pages[start:end],
+                issue_number=issue_number,
+                year=year,
+                issue_url=issue_url,
+            )
+        )
+    ids = [str(record["id"]) for record in records]
+    if len(ids) != len(set(ids)):
+        raise ValueError(f"duplicate DOI-derived IDs in {path}")
+    return records
+def _archive_form_state(page: str) -> dict[str, str]:
+    values = {
+        "viewid": _VIEWID_RE.search(page),
+        "panel": _PANEL_RE.search(page),
+        "combo": _COMBO_RE.search(page),
+        "form": _FORM_RE.search(page),
+    }
+    if not all(values.values()):
+        raise ValueError("archive page does not expose the expected XPages form state")
+    return {key: match.group(1) for key, match in values.items()}  # type: ignore[union-attr]
+def _multipart(fields: dict[str, str]) -> tuple[bytes, str]:
+    boundary = "----WebKitFormBoundary" + uuid.uuid4().hex[:16]
+    body = "".join(
+        f'--{boundary}\r\nContent-Disposition: form-data; name="{name}"\r\n\r\n{value}\r\n'
+        for name, value in fields.items()
+    ) + f"--{boundary}--\r\n"
+    return body.encode("utf-8"), f"multipart/form-data; boundary={boundary}"
+class ArchiveClient:
+    """Browser-TLS client for the Imperva-fronted official archive."""
+    def __init__(self, tries: int = 8, timeout: float = 45.0, pause: float = 2.0):
+        try:
+            from curl_cffi import requests
+        except ImportError as exc:  # pragma: no cover - environment-specific
+            raise RuntimeError(
+                "Studia BAS archive requires browser TLS: pip install curl_cffi"
+            ) from exc
+        self._requests = requests
+        self.tries = tries
+        self.timeout = timeout
+        self.pause = pause
+        self.session = self._new_session()
+        self.state: dict[str, str] | None = None
+    def _new_session(self):
+        return self._requests.Session(impersonate="chrome")
+    def request(self, method: str, url: str, **kwargs):
+        last: BaseException | None = None
+        for attempt in range(self.tries):
+            try:
+                response = getattr(self.session, method)(url, timeout=self.timeout, **kwargs)
+                if int(response.status_code) >= 400:
+                    raise OSError(f"HTTP {response.status_code}")
+                return response
+            except BaseException as exc:
+                if isinstance(exc, (KeyboardInterrupt, SystemExit)):
+                    raise
+                last = exc
+                if attempt == self.tries - 1:
+                    break
+                time.sleep(1.5 * (attempt + 1))
+                self.session = self._new_session()
+                self.state = None
+        raise ConnectionError(f"{method.upper()} {url} failed after {self.tries} attempts") from last
+    def open(self) -> dict[str, str]:
+        if self.state is None:
+            self.state = _archive_form_state(self.request("get", ARCHIVE_URL).text)
+        return self.state
+    def issues_for_year(self, year: int) -> list[ArchiveIssue]:
+        state = self.open()
+        body, content_type = _multipart(
+            {
+                "$$viewid": state["viewid"],
+                state["form"]: state["form"],
+                state["combo"]: str(year),
+            }
+        )
+        url = ARCHIVE_URL + "&$$ajaxid=" + urllib.parse.quote(state["panel"], safe="")
+        response = self.request(
+            "post",
+            url,
+            data=body,
+            headers={
+                "X-Requested-With": "XMLHttpRequest",
+                "Referer": ARCHIVE_URL,
+                "Origin": BASE,
+                "Content-Type": content_type,
+            },
+        )
+        return parse_archive_rows(response.text, year)
+    def download_issue(self, issue: ArchiveIssue, directory: Path) -> Path:
+        directory.mkdir(parents=True, exist_ok=True)
+        path = directory / f"Studia_BAS_{issue.number}.pdf"
+        if path.is_file() and path.stat().st_size and path.read_bytes()[:4] == b"%PDF":
+            return path
+        page = self.request("get", issue.url).text
+        pdf_url = find_issue_pdf_link(page, issue.document_id)
+        if not pdf_url:
+            raise ValueError(f"issue {issue.number} page contains no matching PDF link")
+        content = self.request("get", pdf_url, headers={"Referer": issue.url}).content
+        if not content.startswith(b"%PDF"):
+            raise ValueError(f"issue {issue.number} download did not return a PDF")
+        path.write_bytes(content)
+        time.sleep(self.pause)
+        return path
+def download_archive_years(
+    years: Sequence[int], directory: Path, issues: set[int] | None = None
+) -> list[Path]:
+    """Reproducibly enumerate and cache official issue PDFs."""
+    client = ArchiveClient()
+    paths: list[Path] = []
+    for year in years:
+        for issue in client.issues_for_year(year):
+            if not issue.number or int(issue.number) < MIN_LICENSED_ISSUE:
+                continue
+            if issues is not None and int(issue.number) not in issues:
+                continue
+            paths.append(client.download_issue(issue, directory))
+    return paths
+def _selected_pdfs(directory: Path, issues: set[int] | None) -> list[Path]:
+    paths: list[tuple[int, Path]] = []
+    for path in directory.glob("*.pdf"):
+        match = _ISSUE_RE.search(path.stem)
+        if not match:
+            continue
+        number = int(match.group(1))
+        if number < MIN_LICENSED_ISSUE or (issues is not None and number not in issues):
+            continue
+        paths.append((number, path))
+    return [path for _, path in sorted(paths)]
+PUBLISHER = "Kancelaria Sejmu, Biuro Analiz Sejmowych"
+MODIFICATION_NOTICE = (
+    "Article text was extracted from the text layer of the official issue PDF. "
+    "Running headers, page numbers, author affiliation/contact blocks, and "
+    "terminal bibliographies were removed, residual personal data was replaced "
+    "with [PII], and PDF line wrapping was normalized."
+)
+def read_jsonl(path: Path) -> list[dict[str, object]]:
+    """Read a .jsonl or .jsonl.zst file written by write_jsonl."""
+    if path.suffix == ".zst":
+        import zstandard
+        payload = zstandard.ZstdDecompressor().decompress(
+            path.read_bytes(), max_output_size=1 << 30
+        )
+        text = payload.decode("utf-8")
+    else:
+        text = path.read_text(encoding="utf-8")
+    return [json.loads(line) for line in text.splitlines() if line.strip()]
+def build_attribution_rows(
+    records: Iterable[dict[str, object]],
+    ids: Sequence[str],
+    issue_pdfs: dict[str, dict[str, object]] | None = None,
+) -> list[dict[str, object]]:
+    """One attribution row per Parquet id, in Parquet order.
+    The canonical Parquet keeps only eight columns, so the per-article DOI and
+    the issue PDF an article came from live here instead, which is what CC BY
+    attribution needs.  Building from the Parquet id order is what keeps the two
+    files aligned: an id the source cannot explain raises rather than shifting
+    every later row onto the wrong article.
+    """
+    issue_pdfs = issue_pdfs or {}
+    by_id = {str(record["id"]): record for record in records}
+    rows = []
+    for record_id in ids:
+        record = by_id.get(record_id)
+        if record is None:
+            raise ValueError(f"Parquet id {record_id!r} is absent from the source records")
+        issue = str(record["issue"])
+        pdf = issue_pdfs.get(issue, {})
+        rows.append(
+            {
+                "id": record_id,
+                "doi": record["doi"],
+                "attribution_url": record["source_url"],
+                "archive_url": ARCHIVE_URL,
+                "issue": issue,
+                "issue_pdf_filename": pdf.get("filename", ""),
+                "issue_pdf_sha256": pdf.get("sha256", ""),
+                "author": record["author"],
+                "publisher": PUBLISHER,
+                "license": LICENSE,
+                "license_url": record.get("license_url", CC_BY_URL),
+                "modified": True,
+                "modification_notice": MODIFICATION_NOTICE,
+            }
+        )
+    return rows
+def load_issue_pdfs(evidence: Path) -> dict[str, dict[str, object]]:
+    """Map issue number to the hashed source PDF recorded in the licence evidence."""
+    if not evidence.exists():
+        return {}
+    payload = json.loads(evidence.read_text(encoding="utf-8"))
+    return {str(entry["issue"]): entry for entry in payload.get("eligible_pdfs", [])}
+def write_attribution_sidecar(source: Path, parquet: Path, output: Path, evidence: Path) -> int:
+    """Write the attribution sidecar for an already-built canonical Parquet."""
+    import pyarrow.parquet as pq
+    ids = [str(value) for value in pq.read_table(parquet, columns=["id"])["id"].to_pylist()]
+    rows = build_attribution_rows(read_jsonl(source), ids, load_issue_pdfs(evidence))
+    output.parent.mkdir(parents=True, exist_ok=True)
+    with output.open("w", encoding="utf-8", newline="") as handle:
+        for row in rows:
+            print(json.dumps(row, ensure_ascii=False, sort_keys=True), file=handle)
+    return len(rows)
+def write_jsonl(records: Iterable[dict[str, object]], output: Path) -> int:
+    rows = sorted(records, key=lambda row: str(row["id"]))
+    output.parent.mkdir(parents=True, exist_ok=True)
+    if output.suffix == ".zst":
+        with tempfile.NamedTemporaryFile("w", encoding="utf-8", suffix=".jsonl", delete=False) as handle:
+            temporary = Path(handle.name)
+            for row in rows:
+                handle.write(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n")
+        try:
+            executable = shutil.which("zstd")
+            if executable:
+                subprocess.run([executable, "-19", "-f", str(temporary), "-o", str(output)], check=True)
+            else:
+                try:
+                    import zstandard
+                except ImportError as exc:  # pragma: no cover - environment-specific
+                    raise RuntimeError(
+                        "writing .zst requires zstd or Python zstandard: pip install zstandard"
+                    ) from exc
+                compressor = zstandard.ZstdCompressor(level=19)
+                with temporary.open("rb") as source, output.open("wb") as target:
+                    compressor.copy_stream(source, target)
+        finally:
+            temporary.unlink(missing_ok=True)
+    else:
+        output.write_text(
+            "".join(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n" for row in rows),
+            encoding="utf-8",
+        )
+    return len(rows)
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--pdf-dir",
+        type=Path,
+        default=Path("studia_bas_pdfs"),
+        help="cache directory of official Studia BAS issue PDFs",
+    )
+    parser.add_argument(
+        "--download-years",
+        type=int,
+        nargs="*",
+        help="enumerate these archive years and download missing official PDFs",
+    )
+    parser.add_argument("--issues", type=int, nargs="*", help="continuous issue numbers, e.g. 77")
+    parser.add_argument("--sample", type=int, default=None, help="keep only the first N articles after sorting")
+    parser.add_argument("--out", type=Path, default=Path("studia_bas.jsonl.zst"))
+    parser.add_argument(
+        "--sidecar-parquet",
+        type=Path,
+        help="write the attribution sidecar for this already-built canonical Parquet "
+             "instead of extracting PDFs; --pdf-dir is then unused",
+    )
+    parser.add_argument(
+        "--sidecar-source",
+        type=Path,
+        default=Path("studia_bas.jsonl.zst"),
+        help="source records the Parquet was built from, as written by --out; "
+        "this intermediate is a build input and is not part of the released shard",
+    )
+    parser.add_argument(
+        "--sidecar-out",
+        type=Path,
+        default=Path("data/studia_bas/studia_bas.attribution.jsonl"),
+    )
+    parser.add_argument(
+        "--sidecar-evidence",
+        type=Path,
+        default=Path("data/studia_bas/studia_bas.license-evidence.json"),
+    )
+    args = parser.parse_args()
+    if args.sidecar_parquet:
+        count = write_attribution_sidecar(
+            args.sidecar_source, args.sidecar_parquet, args.sidecar_out, args.sidecar_evidence
+        )
+        print(f"wrote {count} attribution rows to {args.sidecar_out}")
+        return
+    wanted_issues = set(args.issues) if args.issues else None
+    if args.download_years:
+        download_archive_years(args.download_years, args.pdf_dir, wanted_issues)
+    paths = _selected_pdfs(args.pdf_dir, wanted_issues)
+    if not paths:
+        raise SystemExit("no licensed Studia BAS PDFs matched the selection")
+    records: list[dict[str, object]] = []
+    for path in paths:
+        extracted = extract_issue(path)
+        records.extend(extracted)
+        print(f"{path.name}: {len(extracted)} articles", flush=True)
+    records.sort(key=lambda row: str(row["id"]))
+    if args.sample is not None:
+        records = records[: args.sample]
+    count = write_jsonl(records, args.out)
+    print(f"wrote {count} records to {args.out}")
+if __name__ == "__main__":
+    main()

src/report_studia_bas_audit.py ADDED Viewed

	@@ -0,0 +1,98 @@

+"""Render src/audit_studia_bas.py findings as a Markdown report.
+Input is the intermediate JSONL src/fetch_studia_bas.py writes, not the released
+Parquet: the audit reads provenance fields (``source_url``, ``issue_url``) that
+only exist upstream of the canonical eight-column schema.
+"""
+from pathlib import Path
+import sys
+from collections import defaultdict
+from audit_studia_bas import audit_corpus
+import argparse
+EXTRACTION_ISSUES = {"affiliation_block", "navigation_header", "suspicious_hyphenation", "empty_author", "malformed_metadata", "duplicate_id", "duplicate_text"}
+def main():
+    parser = argparse.ArgumentParser()
+    # No default: the intermediate is a build artifact and is not committed, so a
+    # default path would only ever be a stale guess.
+    parser.add_argument("--corpus", type=Path, required=True,
+                        help="intermediate JSONL from src/fetch_studia_bas.py")
+    parser.add_argument("--out", type=Path, default=Path("artifacts/studia_bas_pii_audit.md"))
+    args = parser.parse_args()
+    path = args.corpus
+    if not path.exists():
+        print(f"File not found: {path}")
+        sys.exit(1)
+    results = audit_corpus(path)
+    total_records_checked = 0
+    with open(path, 'r', encoding='utf-8') as f:
+        total_records_checked = sum(1 for line in f if line.strip())
+    report = ["# Studia BAS PII Audit Report\n"]
+    report.append(f"**Total records checked:** {total_records_checked}\n")
+    extraction_by_type = defaultdict(list)
+    pii_by_type = defaultdict(list)
+    for doc_id, issues in results.items():
+        for issue_type, contexts in issues.items():
+            if issue_type in EXTRACTION_ISSUES:
+                extraction_by_type[issue_type].append((doc_id, contexts))
+            else:
+                pii_by_type[issue_type].append((doc_id, contexts))
+    # The verdict is decided by PII only.  The extraction-quality matchers are
+    # deliberately broad and fire on ordinary inline references or citations (institution
+    # names inside texts, "nr 4(12)" issue references, suspended hyphens),
+    # so they are reported as advisory findings and never fail the audit.
+    pii_records = sorted({doc_id for rows in pii_by_type.values() for doc_id, _ in rows})
+    if not pii_records:
+        report.append("## Conclusion: PASS")
+        report.append("No PII detected in any record.")
+    else:
+        report.append("## Conclusion: FAIL")
+        report.append(f"PII detected in {len(pii_records)} records.")
+    report.append("")
+    if extraction_by_type:
+        advisory = sorted({doc_id for rows in extraction_by_type.values() for doc_id, _ in rows})
+        report.append(
+            f"Advisory: {len(advisory)} records matched an extraction-quality "
+            "heuristic. These are not audit failures; review them by hand."
+        )
+        report.append("")
+    if results:
+        if pii_by_type:
+            report.append("## PII Leaks\n")
+            for issue_type, instances in sorted(pii_by_type.items()):
+                report.append(f"### {issue_type} ({len(instances)} affected IDs)")
+                for doc_id, contexts in instances:
+                    report.append(f"- **{doc_id}**")
+                    for ctx in contexts:
+                        if ctx:
+                            report.append(f"  - Context: `{ctx}`")
+                report.append("")
+        if extraction_by_type:
+            report.append("## Extraction Quality Issues\n")
+            for issue_type, instances in sorted(extraction_by_type.items()):
+                report.append(f"### {issue_type} ({len(instances)} affected IDs)")
+                for doc_id, contexts in instances:
+                    report.append(f"- **{doc_id}**")
+                    for ctx in contexts:
+                        if ctx:
+                            report.append(f"  - Context: `{ctx}`")
+                report.append("")
+    report_path = args.out
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+    report_path.write_text("\n".join(report), encoding="utf-8")
+    print(f"Report written to {report_path}")
+if __name__ == "__main__":
+    main()

src/sources.py CHANGED Viewed

@@ -510,6 +510,35 @@ SOURCES = {
         "is_ocr": False,
         "custom_datasheet": True,
     },
     "biblioteka_nauki": {
         "added": "2026-06-27",
         "custom_datasheet": True,

         "is_ocr": False,
         "custom_datasheet": True,
     },
+    "studia_bas": {
+        "file_key": "studia_bas",
+        "preserve_id": True,
+        "preserve_created": True,
+        "added": "2026-07-19",
+        "release": None,
+        "pretty": "Studia BAS — peer-reviewed socioeconomic and public-policy articles",
+        "license": "CC-BY-3.0-PL",
+        "license_spdx": "CC-BY-3.0-PL",
+        "traceable": "Starting with issue 2(66)/2021, Studia BAS publishes its "
+                     "content under Creative Commons Attribution 3.0 Poland. "
+                     "The grant is stated both on the journal open-access page "
+                     "and inside every retained official issue PDF.",
+        "upstream": "https://studiabas.sejm.gov.pl/journal.nsf/pubBAS.xsp?view=12&seria=4&lang=PL",
+        "provenance": "Official issue PDFs are enumerated through the journal's XPages "
+                      "archive and downloaded with browser-TLS transport by "
+                      "src/fetch_studia_bas.py. Text-layer articles are split by DOI "
+                      "title pages; running headers, author affiliation/contact blocks "
+                      "and ORCID values are excluded, common PII is replaced with [PII], "
+                      "terminal bibliographies are removed, and PDF line wrapping is "
+                      "normalized before the canonical build. The preserve_id / "
+                      "preserve_created entry flags require the separate build_dynaword.py "
+                      "change (split out for its own review). Pattern scrubbing only - "
+                      "re-run through SlayerLab/NERGAL before release.",
+        "domain": "academic, economics, social policy and public policy",
+        "created": "2021-2025 (per article in the created column)",
+        "is_ocr": False,
+        "custom_datasheet": True,
+    },
     "biblioteka_nauki": {
         "added": "2026-06-27",
         "custom_datasheet": True,

src/test_audit_studia_bas.py ADDED Viewed

	@@ -0,0 +1,90 @@

+import pytest
+from audit_studia_bas import audit_record
+def get_base_record(text="", author="Jan Kowalski", doc_id="1"):
+    return {
+        "id": doc_id,
+        "text": text,
+        "author": author,
+        "created": "2021",
+        "issue": "66",
+        "license": "CC-BY-3.0-PL",
+        "doi": "10.1",
+        "source": "studia_bas",
+        "source_url": "",
+        "issue_url": "",
+        "license_url": ""
+    }
+def test_empty_author():
+    record = get_base_record(author="   ")
+    issues = audit_record(record, set(), set())
+    assert "empty_author" in issues
+def test_duplicate_id():
+    record = get_base_record(doc_id="id123")
+    seen_ids = {"id123"}
+    issues = audit_record(record, seen_ids, set())
+    assert "duplicate_id" in issues
+def test_duplicate_text():
+    record = get_base_record(text="Some unique text")
+    seen_texts = {"Some unique text"}
+    issues = audit_record(record, set(), seen_texts)
+    assert "duplicate_text" in issues
+def test_email():
+    record = get_base_record(text="Contact me at test@example.com for info.")
+    issues = audit_record(record, set(), set())
+    assert "residual_email" in issues
+def test_orcid():
+    record = get_base_record(text="My ORCID is 0000-0002-1825-0097")
+    issues = audit_record(record, set(), set())
+    assert "orcid_found" in issues
+def test_orcid_corrupted():
+    record = get_base_record(text="O R C I D : 0 0 0 0 - 0 0 0 2 - 1 8 2 5 - 0 0 9 7")
+    issues = audit_record(record, set(), set())
+    assert "orcid_found" in issues
+def test_phone_number():
+    record = get_base_record(text="Zadzwoń: tel. 123 456 789")
+    issues = audit_record(record, set(), set())
+    assert "phone_number" in issues
+def test_pesel():
+    record = get_base_record(text="PESEL 12345678901")
+    issues = audit_record(record, set(), set())
+    assert "pesel" in issues
+def test_nip():
+    record = get_base_record(text="NIP: 123-456-32-18")
+    issues = audit_record(record, set(), set())
+    assert "nip" in issues
+def test_regon():
+    record = get_base_record(text="REGON 123456789")
+    issues = audit_record(record, set(), set())
+    assert "regon" in issues
+def test_author_affiliation():
+    record = get_base_record(text="Mgr inż. Jan Kowalski, Uniwersytet Warszawski")
+    issues = audit_record(record, set(), set())
+    assert "affiliation_block" in issues
+def test_navigation_header():
+    record = get_base_record(text="Studia BAS Nr 4(68) 2021")
+    issues = audit_record(record, set(), set())
+    assert "navigation_header" in issues
+def test_suspicious_hyphenation():
+    record = get_base_record(text="To jest testowe przedsię- biorstwo.")
+    issues = audit_record(record, set(), set())
+    assert "suspicious_hyphenation" in issues
+def test_malformed_metadata():
+    record = get_base_record()
+    del record["created"]
+    issues = audit_record(record, set(), set())
+    assert "malformed_metadata" in issues

src/test_studia_bas_contract.py ADDED Viewed

	@@ -0,0 +1,638 @@

+"""Contract tests for the Studia BAS direct-source contribution."""
+from __future__ import annotations
+import json
+import re
+import sys
+from pathlib import Path
+import pytest
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from fetch_studia_bas import (
+    ArchiveIssue,
+    Block,
+    CC_BY_URL,
+    LICENSE,
+    SOURCE,
+    article_start_indexes,
+    extract_article,
+    find_issue_pdf_link,
+    normalize_pdf_text,
+    parse_archive_rows,
+    scrub_pii,
+)
+def block(text, y0, y1=None, *, x0=57.0, size=9.0, lines=()):
+    return Block(
+        text=text,
+        x0=x0,
+        y0=float(y0),
+        x1=413.0,
+        y1=float(y1 if y1 is not None else y0 + 13),
+        min_size=float(size),
+        max_size=float(size),
+        lines=tuple(lines),
+    )
+def article_fixture():
+    page_one = [
+        block("Magdalena Janiszewska*", 96, x0=64, size=9.5),
+        block("Jan M. Janiszewski**", 111, x0=82, size=9.5),
+        block(
+            "Ulgi podatkowe jako narzędzie wspierania konkurencyjności polskich przedsiębiorstw",
+            93,
+            x0=176,
+            size=13,
+        ),
+        block(
+            "Tax reliefs as a tool to support the competitiveness of Polish enterprises "
+            "The level of innovation and technological advancement is important.",
+            151,
+            size=8,
+            lines=(
+                "Tax reliefs as a tool to support the competitiveness of Polish enterprises",
+                "The level of innovation and technological advancement is important.",
+            ),
+        ),
+        block("DOI https://doi.org/10.31268/StudiaBAS.2024.03", 259, size=8),
+        block(
+            "Słowa kluczowe ulgi podatkowe w Polsce, polityka innowacyjna, konkurencyjność",
+            276,
+            size=8,
+        ),
+        block("Keywords tax reliefs, innovation policy", 303, size=8),
+        block(
+            "O autorach adiunkt, SGH, magdalena.janiszewska@sgh.waw.pl "
+            "https://orcid.org/0000-0001-9442-4426",
+            330,
+            size=8,
+        ),
+        block(
+            "Artykuł został udostępniony na licencji Creative Commons – "
+            "Uznanie Autorstwa 3.0 Polska (CC BY 3.0 PL).",
+            428,
+            size=6,
+        ),
+        block("Wstęp", 463, size=11),
+        block("Zapoczątkowane starania polskiego ustawodawcy na rzecz przedsię-", 488),
+        block("biorców do podejmowania działalności innowacyjnej.", 502),
+        block("1(77) 2024 ISSN 2082-0658 studiabas.sejm.gov.pl 29", 25, size=8),
+    ]
+    page_two = [
+        block("30 studiabas.sejm.gov.pl 1(77) 2024", 25, size=8),
+        block("Kolejny akapit omawia narzędzia fiskalne.", 68, x0=68),
+        block("Bibliografia", 500, size=11),
+        block("Przykładowa pozycja bibliograficzna.", 525),
+    ]
+    return [page_one, page_two]
+def test_normalize_pdf_text_repairs_unicode_whitespace_and_line_hyphenation():
+    raw = "  przedsiębior-\n ców\u00a0\u2009oraz\u200b  inne\u00ad słowa…  "
+    assert normalize_pdf_text(raw) == "przedsiębiorców oraz inne słowa..."
+def test_scrub_pii_replaces_email_orcid_phone_and_polish_identifiers():
+    raw = (
+        "Kontakt: anna@example.org, ORCID 0000-0002-1825-0097, "
+        "https://orcid. org/0000-0003-1111-2222, tel. +48 22 694 17 50, "
+        "PESEL 44051401458, NIP 5260250274, REGON 000261197."
+    )
+    cleaned = scrub_pii(raw)
+    assert "anna@example.org" not in cleaned
+    assert "0000-0002-1825-0097" not in cleaned
+    assert "0000-0003-1111-2222" not in cleaned
+    assert "orcid" not in cleaned.lower()
+    assert "+48 22 694 17 50" not in cleaned
+    assert "44051401458" not in cleaned
+    assert "5260250274" not in cleaned
+    assert "000261197" not in cleaned
+    assert cleaned.count("[PII]") >= 6
+def test_article_start_requires_doi_license_and_large_polish_title():
+    pages = article_fixture()
+    pages.append([block("Cytowanie DOI https://doi.org/10.1/example", 100)])
+    assert article_start_indexes(pages) == [0]
+def test_extract_article_keeps_content_and_metadata_but_drops_author_affiliation_pii():
+    record = extract_article(
+        article_fixture(),
+        issue_number="77",
+        year=2024,
+        issue_url="https://studiabas.sejm.gov.pl/example",
+    )
+    assert record["text"].startswith(
+        "Ulgi podatkowe jako narzędzie wspierania konkurencyjności polskich przedsiębiorstw"
+    )
+    assert "Streszczenie\n\nThe level of innovation" in record["text"]
+    assert "Słowa kluczowe\n\nulgi podatkowe" in record["text"]
+    assert "Wstęp" in record["text"]
+    assert "przedsiębiorców" in record["text"]
+    assert "Bibliografia" not in record["text"]
+    assert "Przykładowa pozycja bibliograficzna." not in record["text"]
+    assert "magdalena.janiszewska@sgh.waw.pl" not in record["text"]
+    assert "orcid" not in record["text"].lower()
+    assert "studiabas.sejm.gov.pl 1(77)" not in record["text"]
+    assert record["author"] == "Magdalena Janiszewska; Jan M. Janiszewski"
+    assert record["created"] == "2024"
+    assert record["license"] == LICENSE
+    assert record["source"] == SOURCE
+    assert record["doi"] == "10.31268/StudiaBAS.2024.03"
+    assert record["id"] == "studia_bas_2024_03"
+    assert record["source_url"] == "https://doi.org/10.31268/StudiaBAS.2024.03"
+    assert record["issue_url"] == "https://studiabas.sejm.gov.pl/example"
+    assert record["license_url"] == CC_BY_URL
+def test_jsonl_record_exposes_metadata_to_the_canonical_builder():
+    record = extract_article(article_fixture(), issue_number="77", year=2024)
+    encoded = json.dumps(record, ensure_ascii=False)
+    decoded = json.loads(encoded)
+    assert decoded["author"]
+    assert decoded["created"] == "2024"
+    assert decoded["license"] == "CC-BY-3.0-PL"
+    assert re.fullmatch(r"studia_bas_\d{4}_\d{2}", decoded["id"])
+class _TokenStub:
+    def encode_ordinary_batch(self, texts, num_threads=1):
+        return [[1] * len(text.split()) for text in texts]
+def test_canonical_builder_preserves_per_record_created_metadata(monkeypatch):
+    import build_dynaword
+    monkeypatch.setattr(build_dynaword, "_ENC", _TokenStub())
+    record = extract_article(article_fixture(), issue_number="77", year=2024)
+    kept, stats = build_dynaword._process_chunk(
+        (False, "2021-2025", LICENSE, True, [json.dumps(record, ensure_ascii=False)])
+    )
+    assert stats[0] == 1
+    assert kept[0][1] == "2024"
+def test_pii_scrub_leaves_public_author_name_available_for_attribution():
+    record = extract_article(article_fixture(), issue_number="77", year=2024)
+    assert "Magdalena Janiszewska" in record["author"]
+    assert "Magdalena Janiszewska" not in record["text"]
+def test_archive_rows_preserve_issue_metadata_and_document_id():
+    fragment = """
+    <table><tr><th>Nr</th><th>Redakcja</th><th>Tytuł</th></tr>
+    <tr><td><a href="pubBAS.xsp?documentId=3624167FFF2C8EFAC1258B25002FE5CA">1(77) 2024</a></td>
+    <td>Adrian Grycuk, Piotr Russel</td><td>Konkurencyjność przedsiębiorstw w Polsce</td></tr></table>
+    """
+    assert parse_archive_rows(fragment, 2024) == [
+        ArchiveIssue(
+            year=2024,
+            number="77",
+            title="Konkurencyjność przedsiębiorstw w Polsce",
+            editor="Adrian Grycuk, Piotr Russel",
+            document_id="3624167FFF2C8EFAC1258B25002FE5CA",
+        )
+    ]
+def test_issue_pdf_link_prefers_the_issue_agent_over_article_agents():
+    issue_id = "3624167FFF2C8EFAC1258B25002FE5CA"
+    article_id = "E93BE3D25D621D1CC1258B25003263B7"
+    page = (
+        f'<a href="/wydbas.nsf/LiczOpen?OpenAgent&amp;{article_id}&amp;lang=PL">article</a>'
+        f'<a href="/wydbas.nsf/LiczOpen?OpenAgent&amp;{issue_id}&amp;lang=PL">issue</a>'
+    )
+    assert issue_id in find_issue_pdf_link(page, issue_id)
+def test_author_line_wrap_fixed():
+    page = [
+        block('Tytuł artykułu', 80, size=13, lines=['Tytuł artykułu']),
+        block('Kamilla Marchewka-', 110, size=9.5, lines=['Kamilla Marchewka-']),
+        block('-Bartkowiak', 125, size=9.5, lines=['-Bartkowiak']),
+        block('10.31268/StudiaBAS.2024.03', 259, size=8),
+        block('Creative Commons Uznanie Autorstwa 3.0 Polska (CC BY 3.0 PL)', 428, size=6)
+    ]
+    # In block helper, title_text/author_text is not set, so we need to set them
+    import dataclasses
+    new_page = []
+    for b in page:
+        if b.y0 == 80: b = dataclasses.replace(b, title_text=b.text)
+        if b.y0 in (110, 125): b = dataclasses.replace(b, author_text=b.text)
+        new_page.append(b)
+    page = new_page
+    from fetch_studia_bas import _front_matter
+    meta = _front_matter(page)
+    assert meta['authors'] == ['Kamilla Marchewka-Bartkowiak']
+def test_doi_ordinal_derivation():
+    from fetch_studia_bas import _front_matter
+    page = [
+        block('Tytuł artykułu', 80, size=13, lines=['Tytuł artykułu']),
+        block('Jan Kowalski', 110, size=9.5, lines=['Jan Kowalski']),
+        block('10.31268/StudiaBAS.2024.1.2', 259, size=8),
+        block('Creative Commons Uznanie Autorstwa 3.0 Polska (CC BY 3.0 PL)', 428, size=6)
+    ]
+    import dataclasses
+    new_page = []
+    for b in page:
+        if b.y0 == 80: b = dataclasses.replace(b, title_text=b.text)
+        if b.y0 == 110: b = dataclasses.replace(b, author_text=b.text)
+        new_page.append(b)
+    page = new_page
+    meta = _front_matter(page)
+    assert meta['ordinal'] == '01_02'
+def test_canonical_builder_falls_back_to_source_created_when_record_metadata_is_absent(monkeypatch):
+    import build_dynaword
+    import json
+    monkeypatch.setattr(build_dynaword, '_ENC', _TokenStub())
+    # Missing 'created' in the record
+    record = {'text': 'To jest testowy polski tekst z polskimi znakami diakrytycznymi ąćęłńóśźż.' * 10}
+    kept, stats = build_dynaword._process_chunk(
+        (False, '2010-2020', 'CC0', True, [json.dumps(record)])
+    )
+    assert kept[0][1] == '2010-2020'
+def test_canonical_builder_backward_compatibility(monkeypatch, tmp_path):
+    import build_dynaword
+    import json
+    monkeypatch.setattr(build_dynaword, '_ENC', _TokenStub())
+    # Missing 'created' falls back to source config
+    record = {'text': 'To jest testowy polski tekst z polskimi znakami diakrytycznymi ąćęłńóśźż.' * 10, 'id': 'custom_123'}
+    kept, _ = build_dynaword._process_chunk(
+        (False, 'fallback_created', 'fallback_license', True, [json.dumps(record)])
+    )
+    assert kept[0][1] == 'fallback_created'
+    assert kept[0][6] == 'custom_123'
+def test_front_matter_cleans_footnote_digits_from_multiple_authors():
+    from fetch_studia_bas import _front_matter
+    page = [
+        block('Tytuł artykułu', 80, size=13, lines=['Tytuł artykułu']),
+        block('1 Jan Kowalski', 110, size=9.5, lines=['1 Jan Kowalski']),
+        block('2 Anna Nowak', 125, size=9.5, lines=['2 Anna Nowak']),
+        block('3 Piotr Zielinski', 140, size=9.5, lines=['3 Piotr Zielinski']),
+        block('10.31268/StudiaBAS.2024.1.2', 259, size=8),
+        block('Creative Commons Uznanie Autorstwa 3.0 Polska (CC BY 3.0 PL)', 428, size=6)
+    ]
+    import dataclasses
+    new_page = []
+    for b in page:
+        if b.y0 == 80: b = dataclasses.replace(b, title_text=b.text)
+        if b.y0 in (110, 125, 140): b = dataclasses.replace(b, author_text=b.text)
+        new_page.append(b)
+    meta = _front_matter(new_page)
+    assert meta['authors'] == ['Jan Kowalski', 'Anna Nowak', 'Piotr Zielinski']
+def test_studia_bas_artifacts():
+    import pyarrow.parquet as pq
+    import json
+    parquet_path = Path("data/studia_bas/studia_bas.parquet")
+    stats_path = Path("data/studia_bas/studia_bas.stats.json")
+    md_path = Path("data/studia_bas/studia_bas.md")
+    assert parquet_path.exists(), "Parquet artifact missing"
+    assert stats_path.exists(), "Stats artifact missing"
+    assert md_path.exists(), "Datasheet missing"
+    table = pq.read_table(parquet_path)
+    # Exact schema
+    import pyarrow as pa
+    expected_schema = pa.schema([
+        ("id", pa.string()), ("text", pa.string()), ("source", pa.string()),
+        ("added", pa.string()), ("created", pa.string()), ("token_count", pa.int64()),
+        ("license", pa.string()), ("author", pa.string()),
+    ])
+    assert table.schema.equals(expected_schema), "Schema mismatch"
+    ids = table["id"].to_pylist()
+    texts = table["text"].to_pylist()
+    sources = table["source"].to_pylist()
+    licenses = table["license"].to_pylist()
+    tokens = table["token_count"].to_pylist()
+    created = table["created"].to_pylist()
+    # Unique IDs/texts
+    assert len(ids) == len(set(ids)), "Duplicate IDs"
+    assert len(texts) == len(set(texts)), "Duplicate texts"
+    # Positive token_count
+    assert all(t > 0 for t in tokens), "Non-positive token count"
+    # Uniform source/license
+    assert all(s == SOURCE for s in sources), "Non-uniform source"
+    assert all(l == LICENSE for l in licenses), "Non-uniform license"
+    # Created range
+    for c in created:
+        year = int(c)
+        assert 2021 <= year <= 2025, f"Created year {year} out of range"
+    # Stats totals
+    stats = json.loads(stats_path.read_text(encoding="utf-8"))
+    assert stats["kept"] == len(ids)
+    assert stats["tokens"] == sum(tokens)
+    assert stats["chars"] == sum(len(t) for t in texts)
+    # Sidecar-Parquet alignment
+    md_content = md_path.read_text(encoding="utf-8")
+    assert str(stats["kept"]) in md_content
+    assert "10.31268/StudiaBAS.2021.26" in md_content
+    assert "10.31268/StudiaBAS.2022.08" in md_content
+    assert "10.31268/StudiaBAS.2025.08" in md_content
+    # Bibliography and Annex checks
+    bib_pattern = re.compile(r"Bibliografia|References|Bibiliografia", re.I)
+    annex_pattern = re.compile(r"^(Aneks|Załącznik)\b", re.I)
+    expected_annex_ids = {
+        "studia_bas_2021_23", "studia_bas_2022_04", "studia_bas_2023_13",
+        "studia_bas_2023_20", "studia_bas_2023_26", "studia_bas_2023_33",
+        "studia_bas_2024_09"
+    }
+    id_to_text = dict(zip(ids, texts))
+    for record_id, t in id_to_text.items():
+        paras = [p.strip() for p in t.split("\n\n")]
+        for p in paras:
+            assert not bib_pattern.fullmatch(p), (
+                f"Found bibliography heading in {record_id}"
+            )
+    for expected_id in expected_annex_ids:
+        assert expected_id in id_to_text, f"Expected annex ID missing: {expected_id}"
+        t = id_to_text[expected_id]
+        paras = [p.strip() for p in t.split("\n\n")]
+        assert any(annex_pattern.match(p) for p in paras), (
+            f"Missing annex in {expected_id}"
+        )
+def _front_matter_authors(author_blocks, *, title_x0=57.0, author_x0=57.0, extra=()):
+    """Run _front_matter over a minimal title page with the given author blocks."""
+    import dataclasses
+    from fetch_studia_bas import _front_matter
+    page = [dataclasses.replace(
+        block('Tytul artykulu', 80, size=13, x0=title_x0, lines=['Tytul artykulu']),
+        title_text='Tytul artykulu',
+    )]
+    y = 105
+    for text in author_blocks:
+        b = block(text, y, size=9.5, x0=author_x0, lines=text.splitlines())
+        page.append(dataclasses.replace(b, author_text=text))
+        y += 15
+    page.extend(extra)
+    page.append(block('10.31268/StudiaBAS.2024.03', 259, size=8))
+    page.append(block(
+        'Creative Commons Uznanie Autorstwa 3.0 Polska (CC BY 3.0 PL)', 428, size=6
+    ))
+    return _front_matter(page)['authors']
+def test_wrapped_given_name_and_surname_form_one_author():
+    # PDF wraps a single long name across two lines with no hyphen.
+    assert _front_matter_authors(['Elzbieta\nMalinowska-Misiag']) == [
+        'Elzbieta Malinowska-Misiag'
+    ]
+def test_one_complete_name_per_line_stays_separate():
+    # Several full names inside one block must not be glued together.
+    assert _front_matter_authors(['Maciej J. Nowak\nBarbara Szulczewska']) == [
+        'Maciej J. Nowak',
+        'Barbara Szulczewska',
+    ]
+def test_wrapped_name_between_two_complete_names():
+    assert _front_matter_authors([
+        'Grzegorz Humenny\nMalgorzata\nKlobuszewska\nTomasz Plachecki'
+    ]) == ['Grzegorz Humenny', 'Malgorzata Klobuszewska', 'Tomasz Plachecki']
+def test_attribution_sidecar_matches_parquet_order():
+    """The sidecar carries the DOI the 8-column Parquet cannot, so it must stay
+    row-for-row aligned with it: same count, same ids, same order."""
+    import json
+    from pathlib import Path
+    import pyarrow.parquet as pq
+    root = Path(__file__).resolve().parent.parent / "data" / SOURCE
+    parquet = root / f"{SOURCE}.parquet"
+    sidecar = root / f"{SOURCE}.attribution.jsonl"
+    if not parquet.exists() or not sidecar.exists():
+        pytest.skip("canonical artifacts are not built in this checkout")
+    ids = [str(v) for v in pq.read_table(parquet, columns=["id"])["id"].to_pylist()]
+    rows = [
+        json.loads(line)
+        for line in sidecar.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    stats = json.loads((root / f"{SOURCE}.stats.json").read_text(encoding="utf-8"))
+    assert len(rows) == len(ids) == stats["kept"]
+    assert [row["id"] for row in rows] == ids
+    for row in rows:
+        assert row["license"] == LICENSE
+        assert row["license_url"] == CC_BY_URL
+        assert row["doi"] and row["attribution_url"].endswith(row["doi"])
+        assert row["issue_pdf_sha256"]
+        assert row["modified"] is True
+        notice = row.get("modification_notice", "").lower()
+        assert "bibliograph" in notice or "reference" in notice, (
+            "Notice must disclose bibliography removal"
+        )
+def test_build_attribution_rows_rejects_unknown_parquet_id():
+    # A missing source record must raise, not silently shift later rows onto
+    # the wrong article.
+    from fetch_studia_bas import build_attribution_rows
+    with pytest.raises(ValueError):
+        build_attribution_rows([], ["studia_bas_2021_15"])
+def test_three_token_name_wrapped_across_blocks_is_one_author():
+    # 10.31268/StudiaBAS.2023.12 sets one author over two blocks and prints no
+    # affiliation marker, because there is no second author to tell apart.
+    assert _front_matter_authors(['Agnieszka Paulina', 'Smolenska']) == [
+        'Agnieszka Paulina Smolenska'
+    ]
+def test_footnote_marker_closes_an_author_at_wrapped_line_pitch():
+    # 10.31268/StudiaBAS.2023.17 stacks three co-authors at the same 12pt pitch a
+    # wrapped name uses, so only the marker separates them.
+    assert _front_matter_authors(
+        ['Zbigniew M. Karaczun*', 'Piotr Swacha**\nTomasz Herudzinski***']
+    ) == ['Zbigniew M. Karaczun', 'Piotr Swacha', 'Tomasz Herudzinski']
+def test_unmarked_line_continues_the_marked_name_above_it():
+    # 10.31268/StudiaBAS.2022.17: the marker sits on the wrap, not on the line
+    # that starts the name.
+    assert _front_matter_authors(
+        ['Grzegorz Humenny*', 'Malgorzata\nKlobuszewska**', 'Tomasz Plachecki***']
+    ) == ['Grzegorz Humenny', 'Malgorzata Klobuszewska', 'Tomasz Plachecki']
+def test_author_list_running_below_the_title_band_is_not_truncated():
+    # 10.31268/StudiaBAS.2023.35 has six authors; the last two sit below the y=155
+    # the ordinary title page never reaches.
+    assert _front_matter_authors(
+        [
+            'Pawel Felis*',
+            'Michal Bernardelli**',
+            'Agnieszka Bem***',
+            'Anita Makowska****',
+            'Milena Kowalska*****',
+            'Grzegorz Otczyk******',
+        ],
+        title_x0=175.9,
+        author_x0=80.0,
+    ) == [
+        'Pawel Felis',
+        'Michal Bernardelli',
+        'Agnieszka Bem',
+        'Anita Makowska',
+        'Milena Kowalska',
+        'Grzegorz Otczyk',
+    ]
+def test_hyphen_wrapped_surname_needs_the_marker_to_close_the_author():
+    # 10.31268/StudiaBAS.2021.33: two authors whose four name tokens are indis-
+    # tinguishable from one wrapped name unless the markers are read.
+    assert _front_matter_authors(
+        ['Elzbieta\nMalinowska-Misiag*', 'Wojciech Misiag**']
+    ) == ['Elzbieta Malinowska-Misiag', 'Wojciech Misiag']
+def test_text_below_the_author_band_is_not_taken_for_an_author():
+    # The band only extends for blocks that continue the author list without a
+    # gap; the abstract further down the page must stay out.
+    assert _front_matter_authors(
+        ['Anna Szelagowska'],
+        title_x0=175.9,
+        author_x0=80.0,
+        extra=[block('Streszczenie artykulu o mieszkalnictwie', 200, size=9.5, x0=80.0)],
+    ) == ['Anna Szelagowska']
+def test_extract_article_removes_bibliography_variants():
+    pages_bib = article_fixture()
+    pages_bib[1].extend([
+        block("Bibiliografia", 600, size=11),
+        block("Item 1", 620)
+    ])
+    record = extract_article(pages_bib, issue_number="77", year=2024, issue_url="")
+    assert "Bibiliografia" not in record["text"]
+    assert "Item 1" not in record["text"]
+    pages_ref = article_fixture()
+    pages_ref[1].extend([
+        block("References", 600, size=11),
+        block("Item 2", 620)
+    ])
+    record = extract_article(pages_ref, issue_number="77", year=2024, issue_url="")
+    assert "References" not in record["text"]
+    assert "Item 2" not in record["text"]
+def test_extract_article_keeps_appendix_after_bibliography():
+    pages = article_fixture()
+    pages[1].extend([
+        block("Załącznik 1", 600, size=11),
+        block("Ważne dane", 620),
+        block("Aneks 2", 640, size=11),
+        block("Inne dane", 660)
+    ])
+    record = extract_article(pages, issue_number="77", year=2024, issue_url="")
+    assert "Bibliografia" not in record["text"]
+    assert "Przykładowa pozycja bibliograficzna" not in record["text"]
+    assert "Załącznik 1\n\nWażne dane\n\nAneks 2\n\nInne dane" in record["text"]
+def test_extract_article_does_not_remove_inline_bibliography_mention():
+    pages = article_fixture()
+    pages[1].insert(1,
+        block("To jest akapit, w którym jest słowo bibliografia na końcu", 400)
+    )
+    record = extract_article(pages, issue_number="77", year=2024, issue_url="")
+    assert "bibliografia" in record["text"]
+def test_remove_terminal_bibliography_variants():
+    from fetch_studia_bas import remove_terminal_bibliography
+    # Variants
+    assert remove_terminal_bibliography("wstęp\n\nBibliografia\n\npoz 1") == "wstęp"
+    assert remove_terminal_bibliography("wstęp\n\nBibiliografia\n\npoz 1") == "wstęp"
+    assert remove_terminal_bibliography("wstęp\n\nReferences\n\npoz 1") == "wstęp"
+    # Bibliography subheadings should be removed
+    assert (
+        remove_terminal_bibliography("wstęp\n\nBibliografia\n\nAkty prawne\n\npoz 1")
+        == "wstęp"
+    )
+    # Inline mentions should NOT be removed
+    text = "W tym zdaniu słowo bibliografia jest użyte."
+    assert remove_terminal_bibliography(text) == text
+    text_multiline = (
+        "Rozdział\n\nW tym rozdziale znajduje się bibliografia, która coś opisuje."
+    )
+    assert remove_terminal_bibliography(text_multiline) == text_multiline
+    # Missing marker (no bibliography heading)
+    assert (
+        remove_terminal_bibliography("wstęp\n\nRozdział\n\nKoniec")
+        == "wstęp\n\nRozdział\n\nKoniec"
+    )
+    # All relevant Aneks/Załącznik heading shapes
+    text_appendix = "wstęp\n\nBibliografia\n\npoz 1\n\nZałącznik 1\n\nTreść"
+    assert (
+        remove_terminal_bibliography(text_appendix)
+        == "wstęp\n\nZałącznik 1\n\nTreść"
+    )
+    text_appendix2 = "wstęp\n\nBibliografia\n\npoz 1\n\nAneks\n\nTreść"
+    assert (
+        remove_terminal_bibliography(text_appendix2)
+        == "wstęp\n\nAneks\n\nTreść"
+    )
+    text_appendix3 = "wstęp\n\nBibliografia\n\npoz 1\n\nAppendix\n\nTreść"
+    assert (
+        remove_terminal_bibliography(text_appendix3)
+        == "wstęp\n\nAppendix\n\nTreść"
+    )
+    text_appendix4 = "wstęp\n\nBibliografia\n\npoz 1\n\nZałącznik 1. Transpozycja\n\nTreść"
+    assert (
+        remove_terminal_bibliography(text_appendix4)
+        == "wstęp\n\nZałącznik 1. Transpozycja\n\nTreść"
+    )