Add European HPLT Polish web filtering workflow

README.md

@@ -91,6 +91,15 @@ workflow therefore separates **source inclusion** from **training mix**:
 - evaluate per-source perplexity and style contamination, not only global loss;
 - treat GPT-2 124M as a cheap dataset probe, not proof of final model quality.
 
+Primary v0.3 web candidate: `ashtok897/european-hplt-v1`. Its card reports
+Polish `pl` coverage of **1,891,358 documents** and **~1.98B estimated tokens**
+with HPLT WDS quality scores, language confidence, URL provenance, MIME type,
+and web-register metadata. The helper `src/filter_european_hplt.py` streams this
+dataset and filters for Polish, non-machine-translated, non-boilerplate,
+domain-filtered natural web text. The dataset card marks it `CC0-1.0`, inherited
+from HPLT v3, but because it is web-crawl derived it remains subject to
+source/provenance review before a final release.
+
 Current review artifacts:
 
 - `configs/source_candidates_v0_3.json` — candidate decisions and license policy.

artifacts/hf_readmes/ashtok897__european-hplt-v1__README.md

@@ -0,0 +1,288 @@
+---
+language:
+- en
+- fr
+- de
+- es
+- pt
+- it
+- nl
+- pl
+- cs
+- uk
+- sv
+- ro
+- hu
+- el
+- da
+- nb
+- sk
+- fi
+- bg
+- ru
+- ca
+- lt
+- lv
+- sl
+- hr
+- sr
+- mk
+- bs
+- be
+- gl
+- eu
+- nn
+- is
+- cy
+- mt
+- lb
+- ga
+- ast
+- fo
+- gd
+- oc
+license: cc0-1.0
+task_categories:
+- text-generation
+- fill-mask
+pretty_name: "European HPLT v1 — 45M docs, 41 languages"
+size_categories:
+- 10M<n<100M
+source_datasets:
+- hplt-project/hplt_monolingual_v3
+tags:
+- european
+- multilingual
+- pretraining
+- hplt
+---
+
+# European HPLT v1
+
+A multilingual pretraining corpus of **45,031,396 documents** (~50.9B estimated tokens, ~190 GB raw JSONL) across **41 European languages**, built from [HPLT Monolingual v3](https://hplt-project.org/datasets/v3) high-quality web crawl data.
+
+The corpus spans Germanic, Romance, Slavic, Celtic, Baltic, Finno-Ugric, Greek, and other European language families. Every document has an HPLT WDS quality score of 10 or higher (the top of the quality distribution).
+
+## Quick Start
+
+```python
+from datasets import load_dataset
+
+# Streaming (recommended — corpus is ~190 GB)
+ds = load_dataset("ashtok897/european-hplt-v1", split="train", streaming=True)
+for row in ds.take(3):
+    print(row["lang"], row["text"][:100])
+
+# Filter by language
+de_ds = ds.filter(lambda x: x["lang"] == "de")
+
+# Full training split (requires disk space)
+ds = load_dataset("ashtok897/european-hplt-v1", split="train")
+```
+
+## Language Distribution
+
+| Language | BCP-47 | Documents | % | Est. Tokens | Avg Words/Doc |
+|---|---|---:|---:|---:|---:|
+| English | `en` | 3,080,434 | 6.84% | ~4.44B | 955 |
+| French | `fr` | 2,726,717 | 6.06% | ~4.56B | 1,073 |
+| German | `de` | 2,723,089 | 6.05% | ~5.23B | 1,051 |
+| Spanish | `es` | 2,463,158 | 5.47% | ~2.91B | 768 |
+| Portuguese | `pt` | 2,171,285 | 4.82% | ~2.46B | 728 |
+| Italian | `it` | 2,168,007 | 4.81% | ~2.88B | 820 |
+| Dutch | `nl` | 1,902,030 | 4.22% | ~1.64B | 538 |
+| Polish | `pl` | 1,891,358 | 4.20% | ~1.98B | 591 |
+| Czech | `cs` | 1,600,788 | 3.55% | ~1.34B | 516 |
+| Ukrainian | `uk` | 1,577,030 | 3.50% | ~1.08B | 381 |
+| Swedish | `sv` | 1,362,129 | 3.02% | ~1.58B | 721 |
+| Romanian | `ro` | 1,329,418 | 2.95% | ~1.29B | 617 |
+| Hungarian | `hu` | 1,328,026 | 2.95% | ~1.36B | 555 |
+| Greek | `el` | 1,322,934 | 2.94% | ~1.41B | 639 |
+| Danish | `da` | 1,085,979 | 2.41% | ~1.16B | 668 |
+| Norwegian Bokmål | `nb` | 1,081,349 | 2.40% | ~0.99B | 586 |
+| Slovak | `sk` | 1,063,235 | 2.36% | ~0.72B | 413 |
+| Finnish | `fi` | 1,062,298 | 2.36% | ~1.64B | 751 |
+| Bulgarian | `bg` | 1,060,225 | 2.35% | ~0.73B | 434 |
+| Russian | `ru` | 1,046,533 | 2.32% | ~3.62B | 1,847 |
+| Catalan | `ca` | 792,769 | 1.76% | ~0.60B | 499 |
+| Lithuanian | `lt` | 792,614 | 1.76% | ~0.52B | 352 |
+| Latvian | `lv` | 784,033 | 1.74% | ~0.55B | 391 |
+| Slovenian | `sl` | 783,987 | 1.74% | ~0.57B | 449 |
+| Croatian | `hr` | 771,689 | 1.71% | ~0.56B | 448 |
+| Serbian | `sr` | 759,832 | 1.69% | ~0.54B | 440 |
+| Macedonian | `mk` | 648,038 | 1.44% | ~0.34B | 333 |
+| Bosnian | `bs` | 642,025 | 1.43% | ~0.44B | 427 |
+| Belarusian | `be` | 639,982 | 1.42% | ~0.38B | 337 |
+| Galician | `gl` | 639,327 | 1.42% | ~0.42B | 424 |
+| Basque | `eu` | 636,441 | 1.41% | ~0.36B | 294 |
+| Norwegian Nynorsk | `nn` | 535,072 | 1.19% | ~0.36B | 437 |
+| Icelandic | `is` | 432,802 | 0.96% | ~0.82B | 1,073 |
+| Welsh | `cy` | 431,246 | 0.96% | ~0.25B | 390 |
+| Maltese | `mt` | 326,736 | 0.73% | ~0.21B | 358 |
+| Luxembourgish | `lb` | 324,914 | 0.72% | ~0.22B | 417 |
+| Irish | `ga` | 321,842 | 0.71% | ~0.21B | 431 |
+| Asturian | `ast` | 215,942 | 0.48% | ~0.19B | 555 |
+| Faroese | `fo` | 209,925 | 0.47% | ~0.10B | 292 |
+| Scottish Gaelic | `gd` | 197,604 | 0.44% | ~0.15B | 502 |
+| Occitan | `oc` | 98,554 | 0.22% | ~0.08B | 530 |
+| **Total** | | **45,031,396** | **100%** | **~50.88B** | **681** |
+
+> Token estimates use chars÷4. Actual count varies by tokenizer.
+
+### Notable observations
+
+- **Russian** has the highest average doc length (1,847 words) — Russian web articles in HPLT v3 tend to be substantially longer than other languages.
+- **Icelandic** has unusually long average doc length (1,073 words) for its size tier, similar to Tier 1 languages.
+- **German** has the highest total token share among Latin-script languages (~5.23B) despite ranking 3rd by doc count.
+- **Estonian** (`et` / `est_Latn`) was targeted but is **not present in HPLT v3 sorted collection** and was excluded.
+
+## Dataset Fields
+
+| Field | Type | Description |
+|---|---|---|
+| `text` | string | Document text |
+| `lang` | string | BCP-47 language code |
+| `url` | string | Source URL |
+| `score` | float | HPLT WDS quality score (raw integer, higher = better; all docs ≥ 10) |
+| `collection` | string | Source MIME type (e.g. `text/html`) |
+| `web-register` | string | Document register/genre code (see Web Registers section) |
+| `prob` | float | Language detection confidence |
+| `char_count` | int | Character count |
+| `word_count` | int | Whitespace-split word count |
+| `doc_id` | string | Unique per-language ID, e.g. `de_0000001` |
+
+## Data Splits
+
+Split ratios are 98% / 1% / 1% over Parquet shards (250,000 rows per shard, ~180 shards total).
+
+| Split | Documents | Shards |
+|---|---:|---:|
+| train | ~44.13M | ~176 |
+| validation | ~450K | ~2 |
+| test | ~450K | ~2 |
+
+### Note on Data Completeness
+
+One shard (`train-00107-of-00181.parquet`) was removed from the published train
+split because Hugging Face's ClamAV scanner flagged a false-positive malware
+signature (`Email.Trojan.Trojan-939`) on email-like text within the crawled web
+content. Parquet files contain only data and cannot execute code — the flag was
+a byte-pattern match against text in the `text` column, not executable malware.
+As a result, the train split contains 176 shards (~44.0M documents) rather than
+177. Remaining file names keep their original `of-00181` suffix for consistency;
+the `datasets` loader globs all available shards, so this does not affect loading.
+
+## How It Was Built
+
+**Source:** HPLT v3 sorted shards (`https://data.hplt-project.org/three/sorted`), which order documents by WDS quality score descending — every document in this corpus has a WDS score of 10 or higher.
+
+**Quality filtering** (applied inline during download):
+- 50–100,000 characters per document
+- Max 50% non-alphabetic characters (Unicode-aware)
+- Min average word length 2.0 characters
+
+**Deduplication:**
+- Exact SHA-256 hash dedup on all languages
+- MinHash near-duplicate removal **disabled** for this release — HPLT v3 already applies global near-deduplication, so re-running MinHash on Indo-European languages adds significant compute for marginal gain. May be re-enabled in a future release.
+
+**Merge:** Languages are interleaved according to configured fractions targeting a balanced multilingual corpus. The `merge.py` step uses an adaptive quota algorithm that:
+- Caps each language at its available document count
+- Auto-excludes languages with less than 10% of their target quota (none were excluded in this release except Estonian, which had 0 data)
+- Redistributes excluded quota across the remaining languages
+- Shuffles the final output (deterministic, seed=42)
+
+**Pipeline code:** [github.com/ashtok/build-multilingual-corpus](https://github.com/ashtok/build-multilingual-corpus)
+
+## Web Register Distribution
+
+HPLT v3 labels documents with a register/genre code:
+
+| Register | Count | % | Meaning |
+|---|---:|---:|---|
+| IP | 14,245,000 | 31.6% | Informational persuasion |
+| NA | 10,847,574 | 24.1% | Narrative |
+| IN | 8,232,732 | 18.3% | Informational description |
+| MT | 3,810,850 | 8.5% | Machine-translated |
+| ID | 1,926,908 | 4.3% | Interactive discussion |
+| OP | 1,823,791 | 4.1% | Opinion |
+| HI | 1,220,284 | 2.7% | How-to / instructional |
+| unknown | 1,176,071 | 2.6% | Unclassified |
+| LY | 233,724 | 0.5% | Lyrical |
+
+> To exclude machine-translated content, filter on `web-register != "MT"` (drops ~8.5%).
+
+## Source Collection Types
+
+| Collection | Count |
+|---|---:|
+| `text/html` | 44,927,249 |
+| `application/atom+xml` | 46,512 |
+| `application/xml` | 22,690 |
+| (empty) | 16,567 |
+| `application/xhtml+xml` | 6,492 |
+| `application/vnd.oasis.opendocument.text` | 2,708 |
+| `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet` | 2,643 |
+| `text/plain` | 1,771 |
+| `application/rss+xml` | 1,700 |
+| `application/epub+zip` | 1,407 |
+
+99.8% of documents are HTML.
+
+## Corpus Statistics Summary
+
+| Metric | Value |
+|---|---:|
+| Total documents | 45,031,396 |
+| Total characters | 203.5B |
+| Total words | 30.7B |
+| Estimated tokens | ~50.9B |
+| Avg doc length (words) | 681 |
+| Median doc length (words) | 264 |
+| Min doc length (words) | 6 |
+| Max doc length (words) | 26,373 |
+
+## Limitations
+
+- **Web text only** — no books, Wikipedia, or structured data
+- **~8.5% machine-translated content** — identifiable via `web-register: MT`
+- **No Estonian** — language unavailable in HPLT v3 sorted collection at corpus build time
+- **No MinHash near-dedup** — exact dedup only (HPLT v3 already applies global near-dedup)
+- **Tier-6 languages are data-limited** — Occitan, Scottish Gaelic, Faroese, Asturian have <250K docs each
+- **Russian has only 1.05M docs** — substantially less than other Tier-1 languages because HPLT v3 sorted shards exhausted at this quality level
+- **No PII filtering beyond HPLT defaults**
+- **Language proportions are partially balanced, not natural** — high-resource languages are slightly down-weighted versus their raw web share to give more space to mid/low-resource languages
+
+## Comparison with Related Corpora
+
+| Corpus | Docs | Languages | Quality bar | Source |
+|---|---:|---:|---|---|
+| **European HPLT v1** | **45.0M** | **41** | WDS ≥ 10 | HPLT v3 |
+| HPLT v3 (raw) | ~21B | 191 | None | HPLT v3 |
+| CulturaX | 6.3T tokens | 167 | Heuristic | mC4 + OSCAR |
+| RedPajama-v2 | 30T tokens | 5 | Quality signals | Common Crawl |
+| OSCAR 23.01 | ~9.8B | 151 | None | Common Crawl |
+
+This corpus trades scale for quality: every document is pre-filtered to the top WDS tier and the language mix is tilted to include lower-resource European languages that are underrepresented in other multilingual corpora.
+
+## Citation
+
+```bibtex
+@dataset{europeanHPLTv1_2026,
+  author    = {Mahajan, Ashutosh},
+  title     = {European {HPLT} v1: A 45M-document Multilingual Corpus for 41 European Languages},
+  year      = {2026},
+  publisher = {Hugging Face},
+  url       = {https://huggingface.co/datasets/ashtok897/european-hplt-v1}
+}
+
+@article{oepen2025hplt,
+  title   = {{HPLT} 3.0: Very Large-Scale Multilingual Resources for {LLM} and {MT}},
+  author  = {Oepen, Stephan and others},
+  journal = {arXiv preprint arXiv:2511.01066},
+  year    = {2025}
+}
+```
+
+## License
+
+[CC0 1.0 Universal](https://creativecommons.org/publicdomain/zero/1.0/) — inherited from HPLT v3.

artifacts/source_candidate_audit_v0_3.json

@@ -1,4 +1,109 @@
 [
+  {
+    "repo_id": "ashtok897/european-hplt-v1",
+    "configured_decision": "accept_after_web_review",
+    "target_bucket": "bulk_pretraining_web",
+    "priority": "high",
+    "notes": "European HPLT v1 has Polish web data (~1.89M docs / ~1.98B estimated tokens) with WDS quality score, language confidence, URL, MIME type, and web-register metadata. HF card/license says CC0-1.0 inherited from HPLT v3; keep web-crawl caveat, URL provenance, domain filtering, machine-translation filtering, and downstream dedup.",
+    "gated": false,
+    "private": false,
+    "downloads": 749,
+    "license_tags": [
+      "cc0-1.0"
+    ],
+    "language_tags": [
+      "en",
+      "fr",
+      "de",
+      "es",
+      "pt",
+      "it",
+      "nl",
+      "pl",
+      "cs",
+      "uk",
+      "sv",
+      "ro",
+      "hu",
+      "el",
+      "da",
+      "nb",
+      "sk",
+      "fi",
+      "bg",
+      "ru",
+      "ca",
+      "lt",
+      "lv",
+      "sl",
+      "hr",
+      "sr",
+      "mk",
+      "bs",
+      "be",
+      "gl",
+      "eu",
+      "nn",
+      "is",
+      "cy",
+      "mt",
+      "lb",
+      "ga",
+      "ast",
+      "fo",
+      "gd",
+      "oc"
+    ],
+    "size_tags": [
+      "10M<n<100M"
+    ],
+    "task_tags": [
+      "text-generation",
+      "fill-mask"
+    ],
+    "readme_license_lines": [
+      "license: cc0-1.0",
+      "## Limitations",
+      "- **Tier-6 languages are data-limited** — Occitan, Scottish Gaelic, Faroese, Asturian have <250K docs each",
+      "## License",
+      "[CC0 1.0 Universal](https://creativecommons.org/publicdomain/zero/1.0/) — inherited from HPLT v3."
+    ],
+    "warnings": [
+      "unknown"
+    ],
+    "sample_files": [
+      ".gitattributes",
+      "README.md",
+      "data/test/train-00179-of-00181.parquet",
+      "data/test/train-00180-of-00181.parquet",
+      "data/train/train-00000-of-00181.parquet",
+      "data/train/train-00001-of-00181.parquet",
+      "data/train/train-00002-of-00181.parquet",
+      "data/train/train-00003-of-00181.parquet",
+      "data/train/train-00004-of-00181.parquet",
+      "data/train/train-00005-of-00181.parquet",
+      "data/train/train-00006-of-00181.parquet",
+      "data/train/train-00007-of-00181.parquet",
+      "data/train/train-00008-of-00181.parquet",
+      "data/train/train-00009-of-00181.parquet",
+      "data/train/train-00010-of-00181.parquet",
+      "data/train/train-00011-of-00181.parquet",
+      "data/train/train-00012-of-00181.parquet",
+      "data/train/train-00013-of-00181.parquet",
+      "data/train/train-00014-of-00181.parquet",
+      "data/train/train-00015-of-00181.parquet",
+      "data/train/train-00016-of-00181.parquet",
+      "data/train/train-00017-of-00181.parquet",
+      "data/train/train-00018-of-00181.parquet",
+      "data/train/train-00019-of-00181.parquet",
+      "data/train/train-00020-of-00181.parquet",
+      "data/train/train-00021-of-00181.parquet",
+      "data/train/train-00022-of-00181.parquet",
+      "data/train/train-00023-of-00181.parquet",
+      "data/train/train-00024-of-00181.parquet",
+      "data/train/train-00025-of-00181.parquet"
+    ]
+  },
   {
     "repo_id": "PleIAs/common_corpus",
     "configured_decision": "accept_after_subset_review",

artifacts/source_candidate_audit_v0_3.md

@@ -2,6 +2,7 @@
 
 | repo | decision | bucket | license tags | gated | warnings |
 |---|---|---|---|---:|---|
+| `ashtok897/european-hplt-v1` | `accept_after_web_review` | `bulk_pretraining_web` | `cc0-1.0` | `False` | `unknown` |
 | `PleIAs/common_corpus` | `accept_after_subset_review` | `bulk_pretraining` | `none` | `False` | `-` |
 | `PleIAs/Polish-PD` | `accept_after_ocr_review` | `bulk_pretraining` | `none` | `False` | `-` |
 | `pelcra/PLLuMIC` | `accept_gated` | `final_phase_sft` | `cc-by-sa-4.0` | `auto` | `-` |
@@ -19,6 +20,23 @@
 | `allegro/summarization-polish-summaries-corpus` | `reject_until_license` | `summarization` | `none` | `False` | `-` |
 | `allegro/polish-question-passage-pairs` | `reject_until_license` | `qa_eval_final_phase` | `none` | `False` | `-` |
 
+## ashtok897/european-hplt-v1
+
+- decision: `accept_after_web_review`
+- bucket: `bulk_pretraining_web`
+- priority: `high`
+- license tags: `cc0-1.0`
+- language tags: `en, fr, de, es, pt, it, nl, pl, cs, uk, sv, ro, hu, el, da, nb, sk, fi, bg, ru, ca, lt, lv, sl, hr, sr, mk, bs, be, gl, eu, nn, is, cy, mt, lb, ga, ast, fo, gd, oc`
+- gated: `False`
+- notes: European HPLT v1 has Polish web data (~1.89M docs / ~1.98B estimated tokens) with WDS quality score, language confidence, URL, MIME type, and web-register metadata. HF card/license says CC0-1.0 inherited from HPLT v3; keep web-crawl caveat, URL provenance, domain filtering, machine-translation filtering, and downstream dedup.
+
+README/license signals:
+- license: cc0-1.0
+- ## Limitations
+- - **Tier-6 languages are data-limited** — Occitan, Scottish Gaelic, Faroese, Asturian have <250K docs each
+- ## License
+- [CC0 1.0 Universal](https://creativecommons.org/publicdomain/zero/1.0/) — inherited from HPLT v3.
+
 ## PleIAs/common_corpus
 
 - decision: `accept_after_subset_review`

artifacts/source_license_review_v0_3.md

@@ -8,6 +8,7 @@ Scope: candidate sources for a larger, more diverse, more natural Polish DynaWor
 
 | source | bucket | decision | license evidence | main risk / condition |
 |---|---|---|---|---|
+| `ashtok897/european-hplt-v1` | bulk pretraining web | `accept_after_web_review` | HF card/license says `CC0-1.0`, inherited from HPLT v3. The card reports Polish `pl`: 1,891,358 docs and ~1.98B estimated tokens, with URL, WDS score, language confidence, MIME type, and web-register metadata. | Web-crawl provenance/copyright risk remains; require URL retention, domain filtering, MT filtering, exact/near dedup, and quality/style probes. |
 | `PleIAs/common_corpus` | bulk pretraining | `accept_after_subset_review` | Card says Common Corpus contains only uncopyrighted or freely licensed data, document-level contextual/license metadata, and commercial/non-commercial use. | Filter Polish records by `license`, source/domain, quality, and duplicate overlap. |
 | `PleIAs/Polish-PD` | bulk pretraining | `accept_after_ocr_review` | Card says entire collection is public domain in all regions and describes EU public-domain criteria. | Strong OCR-noise risk; sample first, then aggressive OCR filtering. |
 | `pelcra/PLLuMIC` | final phase / SFT | `accept_gated` | HF card: `CC-BY-SA-4.0`, Polish, hand-crafted instructions, professional annotators and review. | Gated; small and instruction-formatted, so not bulk pretraining. |
@@ -40,11 +41,12 @@ Operational result: keep `WiktorS/polish-news` out of the clean open corpus. Rev
 
 ## Import order
 
-1. `PleIAs/common_corpus`: inspect Polish subset metadata and select natural, non-legal, non-code records with acceptable license values.
-2. `PleIAs/Polish-PD`: sample OCR quality and filter aggressively.
-3. `pelcra/PLLuMIC`: accept gated terms and import as `dialogue_sft` / final-phase source.
-4. `ipipan/polqa`, `clarin-pl/poquad`, `clarin-pl/PUGG`, `clarin-pl/ComplexQA`: import as QA/eval/final-phase buckets after dedup.
-5. `oscar-corpus/mOSCAR`: only if the above is not enough for modern web diversity and legal review is acceptable.
+1. `ashtok897/european-hplt-v1`: stream-filter `lang=pl`, remove machine-translated/high-boilerplate/domain-blacklisted records, keep URL provenance.
+2. `PleIAs/common_corpus`: inspect Polish subset metadata and select natural, non-legal, non-code records with acceptable license values.
+3. `PleIAs/Polish-PD`: sample OCR quality and filter aggressively.
+4. `pelcra/PLLuMIC`: accept gated terms and import as `dialogue_sft` / final-phase source.
+5. `ipipan/polqa`, `clarin-pl/poquad`, `clarin-pl/PUGG`, `clarin-pl/ComplexQA`: import as QA/eval/final-phase buckets after dedup.
+6. `oscar-corpus/mOSCAR`: only if the above is not enough for modern web diversity and legal review is acceptable.
 
 ## Required gates before publish
 

artifacts/source_scouting_v0_3.md

@@ -6,6 +6,7 @@ Goal: improve training quality by adding contemporary, diverse Polish while keep
 
 | candidate | type | license/status | why useful | action |
 |---|---|---|---|---|
+| `ashtok897/european-hplt-v1` | high-quality European web crawl | `CC0-1.0` per HF card, inherited from HPLT v3; web-crawl caveat | strongest current candidate for modern/natural Polish: ~1.89M PL docs / ~1.98B estimated PL tokens, URL + score + register metadata | stream-filter `pl`, exclude MT, spam, boilerplate, legalish, domain-blacklisted records; keep URL provenance |
 | `PleIAs/common_corpus` | multilingual open corpus | open/traceable per card | large Polish component, diverse domains, provenance-oriented | inspect Polish subset metadata, dedup against existing data |
 | `PleIAs/Polish-PD` | Polish public-domain books/newspapers | public-domain collection, license must be verified per card/source | large, traceable cultural/news-ish historical text; already separate Polish subset | sample OCR quality before inclusion |
 | `pelcra/PLLuMIC` | Polish instruction/dialogue | `CC-BY-SA-4.0`, gated | high-quality hand-crafted Polish instructions/dialogues | use for SFT/final quality phase, not bulk pretraining |
@@ -41,12 +42,13 @@ Goal: improve training quality by adding contemporary, diverse Polish while keep
 
 ## Next import order
 
-1. Inspect and sample `PleIAs/common_corpus` Polish records.
-2. Inspect and sample `PleIAs/Polish-PD`; measure OCR garbage and duplicate overlap.
-3. Add `pelcra/PLLuMIC` as `dialogue_sft` / high-quality final-phase source after accepting HF access terms.
-4. Add QA/eval buckets from `ipipan/polqa`, `clarin-pl/poquad`, `clarin-pl/PUGG`, `clarin-pl/ComplexQA`.
-5. Review `WiktorS/polish-news` provenance before considering contemporary news.
-6. Treat OSCAR/mOSCAR as fallback web source only after license review, boilerplate removal, language filtering, URL/domain filtering, and near-dedup.
+1. Filter `ashtok897/european-hplt-v1` Polish web records with `src/filter_european_hplt.py`.
+2. Inspect and sample `PleIAs/common_corpus` Polish records.
+3. Inspect and sample `PleIAs/Polish-PD`; measure OCR garbage and duplicate overlap.
+4. Add `pelcra/PLLuMIC` as `dialogue_sft` / high-quality final-phase source after accepting HF access terms.
+5. Add QA/eval buckets from `ipipan/polqa`, `clarin-pl/poquad`, `clarin-pl/PUGG`, `clarin-pl/ComplexQA`.
+6. Review `WiktorS/polish-news` provenance before considering contemporary news.
+7. Treat OSCAR/mOSCAR as fallback web source only after license review, boilerplate removal, language filtering, URL/domain filtering, and near-dedup.
 
 ## TVP Info review note
 

configs/source_candidates_v0_3.json

@@ -27,6 +27,13 @@
     ]
   },
   "candidates": [
+    {
+      "repo_id": "ashtok897/european-hplt-v1",
+      "target_bucket": "bulk_pretraining_web",
+      "priority": "high",
+      "decision": "accept_after_web_review",
+      "notes": "European HPLT v1 has Polish web data (~1.89M docs / ~1.98B estimated tokens) with WDS quality score, language confidence, URL, MIME type, and web-register metadata. HF card/license says CC0-1.0 inherited from HPLT v3; keep web-crawl caveat, URL provenance, domain filtering, machine-translation filtering, and downstream dedup."
+    },
     {
       "repo_id": "PleIAs/common_corpus",
       "target_bucket": "bulk_pretraining",

src/filter_common_corpus.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+"""Stream-filter Polish records from PleIAs/common_corpus.
+
+The filter is designed for v0.3 source expansion:
+- keep Polish records with acceptable open licenses,
+- default to natural/diverse written text,
+- skip legal/government, code, semantic data, and existing Wikipedia duplicates,
+- write bounded parquet shards without downloading the full 4.5 TB dataset.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import time
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+from datasets import load_dataset
+
+
+ADDED = "2026-06-16"
+DEFAULT_ALLOWED_LICENSES = {
+    "CC0",
+    "CC-By",
+    "CC-By-SA",
+    "Public Domain",
+    "MIT",
+    "Apache",
+    "Apache-2.0",
+    "BSD",
+    "Open License",
+}
+DEFAULT_EXCLUDED_OPEN_TYPES = {
+    "Open Government",
+    "Open Source",
+    "Semantic data",
+}
+DEFAULT_EXCLUDED_COLLECTIONS = {
+    "Wikipedia",
+    "Wikidata",
+    "VoxPopuli",
+}
+LEGALISH_RE = re.compile(
+    r"\b("
+    r"court|cour|tribunal|judgment|judgement|hansard|parliament|commission|"
+    r"european parliament|legal|law|case law|eur-lex|sejm|senat|"
+    r"sąd|trybunał|wyrok|ustawa|rozporządzenie|parlament"
+    r")\b",
+    re.I,
+)
+BOILERPLATE_RE = re.compile(
+    r"(cookies?|privacy policy|terms of use|all rights reserved|"
+    r"polityka prywatności|regulamin|wszelkie prawa zastrzeżone)",
+    re.I,
+)
+
+SCHEMA = pa.schema(
+    [
+        ("id", pa.string()),
+        ("text", pa.string()),
+        ("source", pa.string()),
+        ("added", pa.string()),
+        ("created", pa.string()),
+        ("token_count", pa.int64()),
+        ("common_corpus_identifier", pa.string()),
+        ("common_corpus_collection", pa.string()),
+        ("common_corpus_open_type", pa.string()),
+        ("common_corpus_license", pa.string()),
+        ("common_corpus_title", pa.string()),
+        ("common_corpus_creator", pa.string()),
+    ]
+)
+
+
+def parse_csv_set(value: str | None) -> set[str]:
+    if not value:
+        return set()
+    return {item.strip() for item in value.split(",") if item.strip()}
+
+
+def license_allowed(license_value: str | None, allowed: set[str]) -> bool:
+    if not license_value:
+        return False
+    normalized = license_value.strip().lower()
+    return any(normalized == item.lower() or normalized.startswith(item.lower()) for item in allowed)
+
+
+def is_legalish(row: dict) -> bool:
+    fields = " ".join(
+        str(row.get(k) or "")
+        for k in ["collection", "open_type", "title", "creator", "identifier"]
+    )
+    return bool(LEGALISH_RE.search(fields))
+
+
+def is_boilerplate_heavy(text: str) -> bool:
+    sample = text[:5000]
+    hits = len(BOILERPLATE_RE.findall(sample))
+    return hits >= 3
+
+
+def keep_row(row: dict, args: argparse.Namespace, allowed_licenses: set[str]) -> tuple[bool, str]:
+    if row.get("language") != "Polish":
+        return False, "language"
+    if args.written_only and row.get("language_type") != "Written":
+        return False, "language_type"
+    if not license_allowed(row.get("license"), allowed_licenses):
+        return False, "license"
+    if row.get("open_type") in args.exclude_open_type:
+        return False, "open_type"
+    if row.get("collection") in args.exclude_collection:
+        return False, "collection"
+    if not args.include_legalish and is_legalish(row):
+        return False, "legalish"
+
+    text = (row.get("text") or "").strip()
+    if len(text) < args.min_chars:
+        return False, "short"
+    if row.get("token_count") and int(row["token_count"]) < args.min_tokens:
+        return False, "few_tokens"
+    if is_boilerplate_heavy(text):
+        return False, "boilerplate"
+    return True, "kept"
+
+
+def write_batch(writer: pq.ParquetWriter, batch: list[dict], source_name: str) -> int:
+    records = {
+        "id": [],
+        "text": [],
+        "source": [],
+        "added": [],
+        "created": [],
+        "token_count": [],
+        "common_corpus_identifier": [],
+        "common_corpus_collection": [],
+        "common_corpus_open_type": [],
+        "common_corpus_license": [],
+        "common_corpus_title": [],
+        "common_corpus_creator": [],
+    }
+    for idx, row in batch:
+        records["id"].append(f"{source_name}_{idx}")
+        records["text"].append((row.get("text") or "").strip())
+        records["source"].append(source_name)
+        records["added"].append(ADDED)
+        records["created"].append(str(row.get("date") or ""))
+        records["token_count"].append(int(row.get("token_count") or 0))
+        records["common_corpus_identifier"].append(str(row.get("identifier") or ""))
+        records["common_corpus_collection"].append(str(row.get("collection") or ""))
+        records["common_corpus_open_type"].append(str(row.get("open_type") or ""))
+        records["common_corpus_license"].append(str(row.get("license") or ""))
+        records["common_corpus_title"].append(str(row.get("title") or ""))
+        records["common_corpus_creator"].append(str(row.get("creator") or ""))
+
+    table = pa.table(records, schema=SCHEMA)
+    writer.write_table(table)
+    return sum(records["token_count"])
+
+
+def parse_args() -> argparse.Namespace:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--repo-id", default="PleIAs/common_corpus")
+    ap.add_argument("--split", default="train")
+    ap.add_argument(
+        "--data-files",
+        default="hf://datasets/PleIAs/common_corpus/common_corpus_*/*.parquet",
+        help="Parquet glob. The dataset default loader only exposes one shard; use this glob for the full corpus.",
+    )
+    ap.add_argument("--out-dir", type=Path, default=Path("data/common_corpus_pl"))
+    ap.add_argument("--source-name", default="common_corpus_pl")
+    ap.add_argument("--max-records", type=int, default=10000)
+    ap.add_argument("--max-tokens", type=int, default=50_000_000)
+    ap.add_argument("--batch-size", type=int, default=1000)
+    ap.add_argument("--min-chars", type=int, default=300)
+    ap.add_argument("--min-tokens", type=int, default=80)
+    ap.add_argument("--allowed-licenses", default=",".join(sorted(DEFAULT_ALLOWED_LICENSES)))
+    ap.add_argument("--exclude-open-type", default=",".join(sorted(DEFAULT_EXCLUDED_OPEN_TYPES)))
+    ap.add_argument("--exclude-collection", default=",".join(sorted(DEFAULT_EXCLUDED_COLLECTIONS)))
+    ap.add_argument("--include-legalish", action="store_true")
+    ap.add_argument("--include-wikipedia", action="store_true")
+    ap.add_argument("--include-government", action="store_true")
+    ap.add_argument("--written-only", action=argparse.BooleanOptionalAction, default=True)
+    ap.add_argument("--dry-run", action="store_true")
+    return ap.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    args.exclude_open_type = parse_csv_set(args.exclude_open_type)
+    args.exclude_collection = parse_csv_set(args.exclude_collection)
+    if args.include_wikipedia:
+        args.exclude_collection.discard("Wikipedia")
+    if args.include_government:
+        args.exclude_open_type.discard("Open Government")
+        args.exclude_collection.discard("VoxPopuli")
+    allowed_licenses = parse_csv_set(args.allowed_licenses)
+
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    out_parquet = args.out_dir / f"{args.source_name}.parquet"
+    out_stats = args.out_dir / f"{args.source_name}.stats.json"
+    out_datasheet = args.out_dir / f"{args.source_name}.md"
+
+    if args.data_files:
+        ds = load_dataset("parquet", data_files=args.data_files, split=args.split, streaming=True)
+    else:
+        ds = load_dataset(args.repo_id, split=args.split, streaming=True)
+    stats = {
+        "read": 0,
+        "kept": 0,
+        "tokens": 0,
+        "chars": 0,
+        "drop": {},
+        "licenses": {},
+        "collections": {},
+        "open_types": {},
+        "source_repo": args.repo_id,
+        "license": "per-record open license from PleIAs/common_corpus metadata",
+        "allowed_licenses": sorted(allowed_licenses),
+        "excluded_open_types": sorted(args.exclude_open_type),
+        "excluded_collections": sorted(args.exclude_collection),
+    }
+    t0 = time.time()
+    writer = None
+    batch: list[tuple[int, dict]] = []
+    next_id = 0
+    try:
+        if not args.dry_run:
+            writer = pq.ParquetWriter(out_parquet, SCHEMA, compression="zstd")
+        for row in ds:
+            stats["read"] += 1
+            keep, reason = keep_row(row, args, allowed_licenses)
+            if not keep:
+                stats["drop"][reason] = stats["drop"].get(reason, 0) + 1
+                continue
+
+            batch.append((next_id, row))
+            next_id += 1
+            stats["kept"] += 1
+            stats["chars"] += len((row.get("text") or "").strip())
+            stats["licenses"][row.get("license") or ""] = stats["licenses"].get(row.get("license") or "", 0) + 1
+            stats["collections"][row.get("collection") or ""] = stats["collections"].get(row.get("collection") or "", 0) + 1
+            stats["open_types"][row.get("open_type") or ""] = stats["open_types"].get(row.get("open_type") or "", 0) + 1
+
+            if len(batch) >= args.batch_size:
+                stats["tokens"] += sum(int(item[1].get("token_count") or 0) for item in batch)
+                if writer:
+                    write_batch(writer, batch, args.source_name)
+                batch.clear()
+
+            if stats["kept"] >= args.max_records or stats["tokens"] >= args.max_tokens:
+                break
+    finally:
+        if batch:
+            stats["tokens"] += sum(int(item[1].get("token_count") or 0) for item in batch)
+            if writer:
+                write_batch(writer, batch, args.source_name)
+        if writer:
+            writer.close()
+
+    stats["secs"] = round(time.time() - t0, 1)
+    stats["out_parquet"] = str(out_parquet) if not args.dry_run else None
+    out_stats.write_text(json.dumps(stats, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    out_datasheet.write_text(
+        "\n".join(
+            [
+                f"# {args.source_name}",
+                "",
+                "Filtered Polish subset of `PleIAs/common_corpus`.",
+                "",
+                f"- source repo: `{args.repo_id}`",
+                "- license basis: per-record `license` metadata from Common Corpus",
+                f"- allowed licenses: `{', '.join(sorted(allowed_licenses))}`",
+                f"- excluded open types: `{', '.join(sorted(args.exclude_open_type))}`",
+                f"- excluded collections: `{', '.join(sorted(args.exclude_collection))}`",
+                f"- records kept: `{stats['kept']:,}`",
+                f"- tokens kept: `{stats['tokens']:,}`",
+                "",
+                "This source must still pass corpus-level exact/near dedup before release.",
+            ]
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+    print(f"read={stats['read']:,} kept={stats['kept']:,} tokens={stats['tokens']:,} secs={stats['secs']}")
+    print(f"licenses={stats['licenses']}")
+    print(f"collections={stats['collections']}")
+    print(f"open_types={stats['open_types']}")
+    print(f"wrote: {out_stats}")
+    if not args.dry_run:
+        print(f"wrote: {out_parquet}")
+    print(f"wrote: {out_datasheet}")
+
+
+if __name__ == "__main__":
+    main()

src/filter_european_hplt.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""Stream-filter Polish documents from ashtok897/european-hplt-v1.
+
+This source is attractive for v0.3 because it adds modern web Polish at scale
+with HPLT quality scores and web-register metadata. It still needs downstream
+dedup and legal/provenance review because it is web-crawl derived data.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import time
+from pathlib import Path
+from urllib.parse import urlparse
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+from datasets import load_dataset
+
+
+ADDED = "2026-06-16"
+SOURCE_NAME = "european_hplt_pl"
+BOILERPLATE_RE = re.compile(
+    r"(cookies?|privacy policy|terms of service|all rights reserved|"
+    r"polityka prywatności|regulamin|wszelkie prawa zastrzeżone|"
+    r"zaloguj|rejestracja|newsletter)",
+    re.I,
+)
+ADULT_SPAM_RE = re.compile(
+    r"(porn|sex|escort|casino|viagra|cialis|bukmacher|hazard|"
+    r"porno|seks|erotycz|kasyno|randki)",
+    re.I,
+)
+LEGALISH_RE = re.compile(
+    r"\b(ustawa|rozporządzenie|dz\\.u\\.|sejm|senat|parlament|eur-lex|"
+    r"trybunał|sąd|wyrok|kodeks|komisja europejska)\b",
+    re.I,
+)
+DEFAULT_EXCLUDED_DOMAIN_PARTS = {
+    ".bip.",
+    "bip.",
+    "docplayer.pl",
+    "mapa-kodow-pocztowych.pl",
+    "slideplayer.pl",
+    "wikipedia.org",
+}
+
+SCHEMA = pa.schema(
+    [
+        ("id", pa.string()),
+        ("text", pa.string()),
+        ("source", pa.string()),
+        ("added", pa.string()),
+        ("created", pa.string()),
+        ("token_count", pa.int64()),
+        ("hplt_doc_id", pa.string()),
+        ("hplt_url", pa.string()),
+        ("hplt_domain", pa.string()),
+        ("hplt_score", pa.float64()),
+        ("hplt_lang_prob", pa.float64()),
+        ("hplt_collection", pa.string()),
+        ("hplt_register_top", pa.string()),
+        ("hplt_register_top_prob", pa.float64()),
+        ("hplt_mt_prob", pa.float64()),
+        ("hplt_char_count", pa.int64()),
+        ("hplt_word_count", pa.int64()),
+    ]
+)
+
+
+def top_register(registers: dict | None) -> tuple[str, float]:
+    if not isinstance(registers, dict) or not registers:
+        return "", 0.0
+    key, value = max(registers.items(), key=lambda kv: kv[1] or 0.0)
+    return str(key), float(value or 0.0)
+
+
+def lang_prob(row: dict) -> float:
+    prob = row.get("prob")
+    if isinstance(prob, list) and prob:
+        return float(prob[0] or 0.0)
+    if isinstance(prob, (int, float)):
+        return float(prob)
+    return 0.0
+
+
+def domain(url: str | None) -> str:
+    if not url:
+        return ""
+    host = urlparse(url).netloc.lower()
+    return host[4:] if host.startswith("www.") else host
+
+
+def is_bad_text(text: str, args: argparse.Namespace) -> tuple[bool, str]:
+    sample = text[:5000]
+    if len(BOILERPLATE_RE.findall(sample)) >= args.max_boilerplate_hits:
+        return True, "boilerplate"
+    if ADULT_SPAM_RE.search(sample):
+        return True, "adult_spam"
+    if not args.include_legalish and LEGALISH_RE.search(sample):
+        return True, "legalish"
+    return False, ""
+
+
+def keep_row(row: dict, args: argparse.Namespace) -> tuple[bool, str]:
+    if row.get("lang") != "pl":
+        return False, "language"
+    if row.get("collection") not in args.allowed_collections:
+        return False, "collection"
+    host = domain(row.get("url"))
+    if any(part in host for part in args.exclude_domain_contains):
+        return False, "domain"
+    if args.max_per_domain and args.domain_counts.get(host, 0) >= args.max_per_domain:
+        return False, "domain_cap"
+    if float(row.get("score") or 0.0) < args.min_score:
+        return False, "score"
+    if lang_prob(row) < args.min_lang_prob:
+        return False, "lang_prob"
+
+    registers = row.get("web-register") or {}
+    mt_prob = float(registers.get("MT", 0.0)) if isinstance(registers, dict) else 0.0
+    if mt_prob >= args.max_mt_prob:
+        return False, "machine_translated"
+
+    reg, reg_prob = top_register(registers)
+    if args.allowed_registers and reg not in args.allowed_registers:
+        return False, "register"
+    if reg_prob < args.min_register_prob:
+        return False, "register_prob"
+
+    text = (row.get("text") or "").strip()
+    if len(text) < args.min_chars:
+        return False, "short"
+    if int(row.get("word_count") or 0) < args.min_words:
+        return False, "few_words"
+
+    bad, reason = is_bad_text(text, args)
+    if bad:
+        return False, reason
+    return True, "kept"
+
+
+def parse_csv(value: str | None) -> set[str]:
+    if not value:
+        return set()
+    return {item.strip() for item in value.split(",") if item.strip()}
+
+
+def estimate_tokens(row: dict) -> int:
+    # HPLT card estimates tokens as chars / 4. Keep the proxy explicit.
+    return max(1, int((row.get("char_count") or len(row.get("text") or "")) / 4))
+
+
+def write_batch(writer: pq.ParquetWriter, batch: list[tuple[int, dict]], source_name: str) -> int:
+    records = {name: [] for name in SCHEMA.names}
+    token_sum = 0
+    for idx, row in batch:
+        registers = row.get("web-register") or {}
+        reg, reg_prob = top_register(registers)
+        tok = estimate_tokens(row)
+        token_sum += tok
+        url = row.get("url") or ""
+        records["id"].append(f"{source_name}_{idx}")
+        records["text"].append((row.get("text") or "").strip())
+        records["source"].append(source_name)
+        records["added"].append(ADDED)
+        records["created"].append("")
+        records["token_count"].append(tok)
+        records["hplt_doc_id"].append(str(row.get("doc_id") or ""))
+        records["hplt_url"].append(url)
+        records["hplt_domain"].append(domain(url))
+        records["hplt_score"].append(float(row.get("score") or 0.0))
+        records["hplt_lang_prob"].append(lang_prob(row))
+        records["hplt_collection"].append(str(row.get("collection") or ""))
+        records["hplt_register_top"].append(reg)
+        records["hplt_register_top_prob"].append(reg_prob)
+        records["hplt_mt_prob"].append(float(registers.get("MT", 0.0)) if isinstance(registers, dict) else 0.0)
+        records["hplt_char_count"].append(int(row.get("char_count") or len(row.get("text") or "")))
+        records["hplt_word_count"].append(int(row.get("word_count") or 0))
+    writer.write_table(pa.table(records, schema=SCHEMA))
+    return token_sum
+
+
+def parse_args() -> argparse.Namespace:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--repo-id", default="ashtok897/european-hplt-v1")
+    ap.add_argument("--split", default="train")
+    ap.add_argument("--out-dir", type=Path, default=Path("data/european_hplt_pl"))
+    ap.add_argument("--source-name", default=SOURCE_NAME)
+    ap.add_argument("--max-records", type=int, default=100_000)
+    ap.add_argument("--max-tokens", type=int, default=100_000_000)
+    ap.add_argument("--batch-size", type=int, default=1000)
+    ap.add_argument("--min-score", type=float, default=10.0)
+    ap.add_argument("--min-lang-prob", type=float, default=0.80)
+    ap.add_argument("--max-mt-prob", type=float, default=0.20)
+    ap.add_argument("--min-register-prob", type=float, default=0.0)
+    ap.add_argument("--allowed-registers", default="ID,OP,HI,IN,NA")
+    ap.add_argument("--allowed-collections", default="text/html,text/plain,application/xhtml+xml")
+    ap.add_argument("--exclude-domain-contains", default=",".join(sorted(DEFAULT_EXCLUDED_DOMAIN_PARTS)))
+    ap.add_argument("--max-per-domain", type=int, default=250)
+    ap.add_argument("--min-chars", type=int, default=400)
+    ap.add_argument("--min-words", type=int, default=80)
+    ap.add_argument("--max-boilerplate-hits", type=int, default=3)
+    ap.add_argument("--include-legalish", action="store_true")
+    ap.add_argument("--dry-run", action="store_true")
+    return ap.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    args.allowed_registers = parse_csv(args.allowed_registers)
+    args.allowed_collections = parse_csv(args.allowed_collections)
+    args.exclude_domain_contains = parse_csv(args.exclude_domain_contains)
+    args.domain_counts = {}
+    args.out_dir.mkdir(parents=True, exist_ok=True)
+    out_parquet = args.out_dir / f"{args.source_name}.parquet"
+    out_stats = args.out_dir / f"{args.source_name}.stats.json"
+    out_datasheet = args.out_dir / f"{args.source_name}.md"
+
+    ds = load_dataset(args.repo_id, split=args.split, streaming=True)
+    writer = None if args.dry_run else pq.ParquetWriter(out_parquet, SCHEMA, compression="zstd")
+    stats = {
+        "read": 0,
+        "kept": 0,
+        "tokens": 0,
+        "chars": 0,
+        "drop": {},
+        "registers": {},
+        "collections": {},
+        "domains_top_sample": {},
+        "source_repo": args.repo_id,
+        "license": "CC0-1.0 per dataset card; web-crawl provenance requires review",
+        "filters": {
+            "allowed_registers": sorted(args.allowed_registers),
+            "allowed_collections": sorted(args.allowed_collections),
+            "exclude_domain_contains": sorted(args.exclude_domain_contains),
+            "max_per_domain": args.max_per_domain,
+            "min_score": args.min_score,
+            "min_lang_prob": args.min_lang_prob,
+            "max_mt_prob": args.max_mt_prob,
+            "min_chars": args.min_chars,
+            "min_words": args.min_words,
+        },
+    }
+    t0 = time.time()
+    batch: list[tuple[int, dict]] = []
+    next_id = 0
+    try:
+        for row in ds:
+            stats["read"] += 1
+            keep, reason = keep_row(row, args)
+            if not keep:
+                stats["drop"][reason] = stats["drop"].get(reason, 0) + 1
+                continue
+
+            registers = row.get("web-register") or {}
+            reg, _ = top_register(registers)
+            stats["registers"][reg] = stats["registers"].get(reg, 0) + 1
+            coll = row.get("collection") or ""
+            stats["collections"][coll] = stats["collections"].get(coll, 0) + 1
+            host = domain(row.get("url"))
+            args.domain_counts[host] = args.domain_counts.get(host, 0) + 1
+            if len(stats["domains_top_sample"]) < 500:
+                stats["domains_top_sample"][host] = stats["domains_top_sample"].get(host, 0) + 1
+            stats["chars"] += int(row.get("char_count") or len(row.get("text") or ""))
+            stats["kept"] += 1
+            batch.append((next_id, row))
+            next_id += 1
+
+            if len(batch) >= args.batch_size:
+                if writer:
+                    stats["tokens"] += write_batch(writer, batch, args.source_name)
+                else:
+                    stats["tokens"] += sum(estimate_tokens(item[1]) for item in batch)
+                batch.clear()
+            if stats["kept"] >= args.max_records or stats["tokens"] >= args.max_tokens:
+                break
+    finally:
+        if batch:
+            if writer:
+                stats["tokens"] += write_batch(writer, batch, args.source_name)
+            else:
+                stats["tokens"] += sum(estimate_tokens(item[1]) for item in batch)
+        if writer:
+            writer.close()
+
+    stats["secs"] = round(time.time() - t0, 1)
+    stats["out_parquet"] = None if args.dry_run else str(out_parquet)
+    out_stats.write_text(json.dumps(stats, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    out_datasheet.write_text(
+        "\n".join(
+            [
+                f"# {args.source_name}",
+                "",
+                "Filtered Polish subset of `ashtok897/european-hplt-v1`.",
+                "",
+                f"- source repo: `{args.repo_id}`",
+                "- license tag/card: `CC0-1.0`, inherited from HPLT v3",
+                "- caveat: web-crawl derived data; keep URL provenance and run downstream review",
+                f"- allowed registers: `{', '.join(sorted(args.allowed_registers))}`",
+                f"- records kept: `{stats['kept']:,}`",
+                f"- token proxy kept: `{stats['tokens']:,}`",
+                "",
+                "This source must still pass exact/near dedup, boilerplate review, and per-source style/perplexity checks before release.",
+            ]
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+
+    print(f"read={stats['read']:,} kept={stats['kept']:,} tokens={stats['tokens']:,} secs={stats['secs']}")
+    print(f"registers={stats['registers']}")
+    print(f"collections={stats['collections']}")
+    print(f"drops={stats['drop']}")
+    print(f"wrote: {out_stats}")
+    if not args.dry_run:
+        print(f"wrote: {out_parquet}")
+    print(f"wrote: {out_datasheet}")
+    sys.stdout.flush()
+    os._exit(0)
+
+
+if __name__ == "__main__":
+    main()