Repair v0.3.0: document-disjoint splits, explicit scope, lossless quarantine and rebuilt Slayer packs

Preserve all 22,331 original records and original attribution. Retain 15,809 technical/science chunks, quarantine 6,522 with reasons. Verify exact reencoding of all native token packs, all proxy counts, source-group isolation and eight-column conservation. Preserve prior revision with pre-repair-0.3.0 tag.

.gitattributes

@@ -59,3 +59,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
 slayer_v6/train/docs.idx filter=lfs diff=lfs merge=lfs -text
+provenance/records.jsonl filter=lfs diff=lfs merge=lfs -text
+provenance/source_metadata.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -8,17 +8,13 @@ task_categories:
 - text-generation
 library_name: datasets
 size_categories:
-- 10M<n<100M
+- 10K<n<100K
 tags:
 - polish
 - technical
 - cnc
-- industrial-maintenance
 - automation
-- plc
-- robotics
 - dynaword
-- parquet
 configs:
 - config_name: default
   data_files:
@@ -30,16 +26,31 @@ configs:
     path: data/test.parquet
 ---
 
-# Polish technical mega DynaWord
+# Polish technical mega DynaWord — repaired v0.3.0
 
-Large deduplicated Polish technical corpus covering CNC, machine tools, industrial maintenance, automation, PLC, robotics, mechatronics, engineering, energy systems and open technical textbooks.
+Polski korpus techniki i nauk ścisłych: przemysł, CNC, automatyka, informatyka, matematyka, fizyka i chemia. To teksty dokumentów, nie zbiór instrukcji do chatbota ani zatwierdzone procedury obsługi maszyn.
 
-This is a document/chunk corpus, not a question-answer set. Licences are retained per record; provenance and source hashes are included.
+## What changed
 
-It contains 22331 unique documents and 40468328 proxy tokens.
+Chunks of one article/book now share one split. Shared PDF checksums, alternate source identities, ZPE page IDs and overlapping AGH book memberships are joined transitively. Wikibooks selection is an explicit review of book titles, not keyword deletion inside chapters. Out-of-scope content, historical technical scans and verified damaged article 103741 are preserved in quarantine with reasons. Text is not rewritten or completed by a language model. Samples cover source families rather than just the first alphabetic source.
 
-| Split | Documents | Tokens |
-|---|---:|---:|
-| train | 20095 | 36294819 |
-| valid | 1135 | 2157694 |
-| test | 1101 | 2015815 |
+Baseline revision: `66ea025cb1b47bdc08df2e4bed10c091a62a4f8c`. All 22,331 original unique records remain accounted for: **15,809 retained**, **6,522 quarantined**. The previous revision remains available in repository history and under `pre-repair-0.3.0`.
+
+| Split | Text chunks | Document/book groups | Proxy tokens (`cl100k_base`) |
+|---|---:|---:|---:|
+| train | 13724 | 1874 | 25422631 |
+| valid | 940 | 133 | 1822166 |
+| test | 1145 | 108 | 4813267 |
+| quarantine | 6522 | 196 | 8410264 |
+
+## Files and reproducibility
+
+`data/*.parquet` keeps the eight-column DynaWord schema. The explicit default config excludes quarantine. `provenance/records.jsonl` maps every retained/quarantined record to a document group, content hashes, aliases, exclusion reasons and quality flags. `provenance/source_metadata.jsonl` preserves original attribution. `processing/` contains the builder, explicit curation policy, packer and validators; rebuilding requires the original local source layers/metadata referenced by the builder, which are not all standalone Hub datasets. The published validation report checks the delivered artifacts without downloading original PDFs.
+
+`slayer_v6/` contains freshly regenerated little-endian uint16 native Slayer tokens, EOS 0 after each chunk and uint64 end offsets; see its manifest for exact token counts and tokenizer SHA256. `manifest.json` counts are **proxy tokens**, not native Slayer token counts.
+
+## Limits and training use
+
+Group-disjoint splitting prevents the identified document/chunk leakage, not every near-duplicate, semantic overlap or pretraining contamination. All source text has not received expert factual/OCR review; remaining Unicode quality flags are explicit. Historical text is not current operating guidance. Licence metadata is retained, not independently cleared. Observe original attribution/share-alike terms.
+
+**Do not compare old and new validation curves as if the holdout were unchanged.** Do not reuse old dataloader offsets with these regenerated packs. A model already trained on old held-out material does not regain an unseen test set through repartitioning.

data/test.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9a2489fe37c1c80c2e2d571096b0d629d5aa3c95651e0c1b3bf9c1449f517730
-size 2146703
+oid sha256:3f8d26726f02be90766be5366a2915eb7620cf098a921608e01bc1c8a7be04dc
+size 2143222

data/train.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:816c77e079759a2710fff4005478a6ea16c31b6de33d8c2e01b3ef3883bee8cf
-size 37081956
+oid sha256:bb0f18cdf92494ab9d4fbb1910256d923189677c53771c3e6447b56dfad7aeca
+size 27290752

data/validation.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:082ef346584978005bb4c2b4eb96c0e85f54cff5f84f168160b165c04bf8d32f
-size 2371271
+oid sha256:cf75b249ae5add415926856833ddcfaa06f89665eefed739bd1275f9c8bccd51
+size 1869770

licenses/SOURCES.md

@@ -1,7 +1,5 @@
 # Source and licence policy
 
-This mega-corpus consolidates audited local layers. Each record retains its original `source` and `license`; `provenance/records.jsonl` records the input path and text hash.
+Each row preserves its original licence and author. `provenance/source_metadata.jsonl` preserves source URLs, attribution, book memberships and available checksums. Join by record ID, including duplicate identities recorded in `provenance/records.jsonl`. Follow each original licence, including attribution/share-alike requirements. No blanket relicensing or independent rights clearance is claimed.
 
-Included families: Polish CNC/technical DynaWord, industrial maintenance, industrial automation/control, new engineering, ZPE CNC, Open AGH, Open ICM, ROCK/Politechnika Lubelska and selected Wikibooks engineering texts.
-
-Evaluation-only files, the non-technical `studia_bas` layer and records with non-commercial, no-derivatives, proprietary or all-rights-reserved labels are excluded.
+Historical scans, out-of-scope books and a verified damaged article are preserved in `quarantine/records.parquet`; they are not default training data. Per-record exclusions and quality flags are in provenance. Missing OCR words are never guessed.

manifest.json

@@ -1,6 +1,6 @@
 {
   "dataset": "Polish technical mega DynaWord",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "language": [
     "pl"
   ],
@@ -14,23 +14,20 @@
     "license",
     "author"
   ],
+  "base_hub_revision": "66ea025cb1b47bdc08df2e4bed10c091a62a4f8c",
   "layout": {
     "train": "data/train.parquet",
     "valid": "data/validation.parquet",
     "test": "data/test.parquet",
-    "samples": "samples/{train,valid,test}.jsonl"
+    "quarantine": "quarantine/records.parquet"
   },
-  "scope": "Polish technical mega-corpus: CNC, machine tools, industrial maintenance, automation, PLC, robotics, mechatronics, engineering, chemistry, energy systems and open technical textbooks.",
-  "source_policy": "Only audited local layers with per-record CC BY, CC BY-SA, CC0, public-domain, GFDL or GPL metadata; evaluation splits and forbidden licences excluded.",
-  "deduplication": "Exact normalized-text deduplication across every selected input layer and within this dataset.",
-  "documents": 22331,
-  "tokens": 40468328,
+  "scope": "Technology, engineering, mathematics, physics, chemistry and computing; user-selected scope.",
+  "proxy_tokenizer": "cl100k_base",
+  "documents": 15809,
+  "tokens": 32058064,
   "sources": {
-    "bcpw-public-domain": {
-      "documents": 1398
-    },
     "bibliotekanauki-automation": {
-      "documents": 2262
+      "documents": 2258
     },
     "bibliotekanauki-engineering-new": {
       "documents": 4756
@@ -42,7 +39,7 @@
       "documents": 370
     },
     "open_icm_pl": {
-      "documents": 11
+      "documents": 1
     },
     "rock-pollub-open": {
       "documents": 569
@@ -51,10 +48,7 @@
       "documents": 8
     },
     "wikibooks": {
-      "documents": 9040
-    },
-    "wikisource-maszynisci-1873": {
-      "documents": 148
+      "documents": 4078
     },
     "zpe-cnc-pl": {
       "documents": 648
@@ -62,18 +56,80 @@
   },
   "splits": {
     "train": {
-      "documents": 20095,
-      "tokens": 36294819
+      "documents": 13724,
+      "document_groups": 1874,
+      "tokens": 25422631,
+      "sources": {
+        "bibliotekanauki-automation": 2015,
+        "bibliotekanauki-engineering-new": 4101,
+        "bibliotekanauki-maintenance": 2850,
+        "open_agh_chemistry_pl": 186,
+        "rock-pollub-open": 501,
+        "rock_pollub_pl": 7,
+        "wikibooks": 3479,
+        "zpe-cnc-pl": 585
+      }
     },
     "valid": {
-      "documents": 1135,
-      "tokens": 2157694
+      "documents": 940,
+      "document_groups": 133,
+      "tokens": 1822166,
+      "sources": {
+        "bibliotekanauki-automation": 144,
+        "bibliotekanauki-engineering-new": 354,
+        "bibliotekanauki-maintenance": 160,
+        "open_agh_chemistry_pl": 184,
+        "rock_pollub_pl": 1,
+        "wikibooks": 54,
+        "zpe-cnc-pl": 43
+      }
     },
     "test": {
-      "documents": 1101,
-      "tokens": 2015815
+      "documents": 1145,
+      "document_groups": 108,
+      "tokens": 4813267,
+      "sources": {
+        "bibliotekanauki-automation": 99,
+        "bibliotekanauki-engineering-new": 301,
+        "bibliotekanauki-maintenance": 111,
+        "open_icm_pl": 1,
+        "rock-pollub-open": 68,
+        "wikibooks": 545,
+        "zpe-cnc-pl": 20
+      }
     }
   },
+  "quarantine": {
+    "documents": 6522,
+    "document_groups": 196,
+    "tokens": 8410264,
+    "sources": {
+      "bcpw-public-domain": 1398,
+      "bibliotekanauki-automation": 4,
+      "open_icm_pl": 10,
+      "wikibooks": 4962,
+      "wikisource-maszynisci-1873": 148
+    },
+    "reasons": {
+      "historical_technical_archive_not_current_training": 1546,
+      "outside_selected_book_scope": 4972,
+      "verified_unreliable_pdf_text_layout": 4
+    }
+  },
+  "conservation": {
+    "records": 22331,
+    "id_source_text_sha256_preserved": true,
+    "retained_records": 15809,
+    "quarantined_records": 6522
+  },
+  "deduplication": "Exact whitespace-normalized casefolded text; duplicate provenance aliases join the same group.",
+  "split_policy": "SHA256 of canonical document/book alias component; <5 test, <10 valid, otherwise train. Biblioteka uses original numeric article-ID seeds.",
+  "source_policy": "Original attribution and per-record licences preserved; no blanket relicensing. Metadata labels are not independent legal clearance.",
+  "limitations": [
+    "Near-duplicate and semantic overlap are not ruled out.",
+    "Source facts and all OCR text have not been manually validated.",
+    "Existing model pretraining contamination is not ruled out."
+  ],
   "input_files": 21,
   "input_rows": 24029,
   "duplicate_rows": 1698,

processing/build_polish_technical_mega_dynaword.py

@@ -0,0 +1,257 @@
+"""Build an auditable, document-disjoint technical corpus without replacing old data."""
+from __future__ import annotations
+
+import argparse
+from collections import Counter, defaultdict
+from datetime import date
+import hashlib
+import json
+from pathlib import Path
+import re
+import shutil
+
+import tiktoken
+import pyarrow as pa
+import pyarrow.parquet as pq
+from technical_corpus_curation import POLICY, assign_groups, balanced_samples, load_metadata
+
+ROOT = Path(__file__).resolve().parents[1]
+DATASET = ROOT / "data" / "polish_technical_mega_dynaword_v0_3_0"
+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()),
+])
+INPUTS = (
+    ROOT / "data" / "polish_cnc_technical_dynaword" / "data",
+    ROOT / "data" / "polish_cnc_technical_support_dynaword" / "data",
+    ROOT / "data" / "polish_industrial_maintenance_dynaword" / "data",
+    ROOT / "data" / "polish_automation_control_dynaword" / "data",
+    ROOT / "data" / "zpe_cnc_pl_dynaword" / "data",
+    ROOT / "data" / "polish_source_subset" / "data" / "open_agh_chemistry_pl",
+    ROOT / "data" / "polish_source_subset" / "data" / "open_icm_pl",
+    ROOT / "data" / "polish_source_subset" / "data" / "rock_pollub_pl",
+    ROOT / "data" / "polish_source_subset" / "data" / "wikibooks",
+    ROOT / "data" / "polish_engineering_new_dynaword" / "data",
+)
+FORBIDDEN_LICENSE_TERMS = ("noncommercial", "no derivatives", "all rights reserved", "proprietary")
+CONTROL_RE = re.compile(r"[\x00-\x08\x0b-\x1f\x7f]")
+
+
+def norm(text: str) -> str:
+    return " ".join(text.split()).casefold()
+
+
+def sha256(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def input_files() -> list[Path]:
+    return sorted(path for root in INPUTS for path in root.glob("*.parquet"))
+
+
+def load_records() -> tuple[list[dict], dict, Counter]:
+    records: list[dict] = []
+    seen: dict[str, dict] = {}
+    stats = {"input_files": 0, "input_rows": 0, "duplicate_rows": 0, "forbidden_license_rows": 0, "control_chars_removed": 0}
+    encoder = tiktoken.get_encoding("cl100k_base")
+    source_stats: Counter = Counter()
+    for path in input_files():
+        stats["input_files"] += 1
+        table = pq.read_table(path)
+        for row in table.to_pylist():
+            stats["input_rows"] += 1
+            license_name = str(row.get("license") or "")
+            if any(term in license_name.casefold() for term in FORBIDDEN_LICENSE_TERMS):
+                raise ValueError(f"Unreviewed restricted licence: {path}: {row['id']}")
+            text = row.get("text") or ""
+            cleaned = CONTROL_RE.sub("", text)
+            stats["control_chars_removed"] += len(text) - len(cleaned)
+            key = sha256(norm(cleaned))
+            if key in seen:
+                stats["duplicate_rows"] += 1
+                alias = {"id": str(row["id"]), "source": str(row.get("source") or path.parent.name)}
+                if alias not in seen[key]["_aliases"]:
+                    seen[key]["_aliases"].append(alias)
+                continue
+            source = str(row.get("source") or path.parent.name)
+            record = {
+                "id": str(row["id"]),
+                "text": cleaned,
+                "source": source,
+                "added": str(row.get("added") or date.today().isoformat()),
+                "created": str(row.get("created") or ""),
+                "token_count": len(encoder.encode_ordinary(cleaned)) if cleaned != text else int(row.get("token_count") or 0),
+                "license": license_name,
+                "author": str(row.get("author") or ""),
+                "_text_sha256": key,
+                "_input_path": str(path.relative_to(ROOT)),
+                "_aliases": [],
+            }
+            records.append(record)
+            seen[key] = record
+            source_stats[source] += 1
+    return records, stats, source_stats
+
+
+def json_file(path: Path, value: dict) -> None:
+    path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+
+def clean_record(record: dict) -> dict:
+    return {field.name: record[field.name] for field in SCHEMA}
+
+
+def assert_baseline(records: list[dict], baseline: Path) -> dict:
+    original = [row for path in sorted((baseline / "data").glob("*.parquet")) for row in pq.read_table(path).to_pylist()]
+    fingerprints = lambda rows: {(row["id"], row["source"], sha256(row["text"])) for row in rows}
+    current, previous = fingerprints(records), fingerprints(original)
+    if not previous or current != previous:
+        raise ValueError(f"Inputs changed from the audited baseline: added={len(current - previous)}, missing={len(previous - current)}")
+    return {"records": len(original), "id_source_text_sha256_preserved": True}
+
+
+def write_dataset(records: list[dict], stats: dict, metadata: dict, policy: dict, output: Path, baseline_check: dict) -> dict:
+    # Exclusive creation protects the previous corpus, packs and unrelated files.
+    output.mkdir(parents=True, exist_ok=False)
+    for folder in ("data", "samples", "provenance", "licenses", "quarantine", "processing"):
+        (output / folder).mkdir()
+    assign_groups(records, metadata, policy)
+    split_records: dict[str, list[dict]] = defaultdict(list)
+    for record in records:
+        split_records[record["_split"]].append(record)
+    sample_manifest = {"schema": SCHEMA.names, "max_rows": 32, "method": "Round robin across sources, distinct document groups first", "splits": {}}
+    split_manifest = {}
+    for split in ("train", "valid", "test", "quarantine"):
+        rows = sorted(split_records[split], key=lambda item: item["id"])
+        path = output / "quarantine/records.parquet" if split == "quarantine" else output / "data" / f"{'validation' if split == 'valid' else split}.parquet"
+        pq.write_table(pa.Table.from_pylist([clean_record(row) for row in rows], schema=SCHEMA), path, compression="zstd")
+        split_manifest[split] = {
+            "documents": len(rows), "document_groups": len({row["_group_id"] for row in rows}),
+            "tokens": sum(row["token_count"] for row in rows),
+            "sources": dict(sorted(Counter(row["source"] for row in rows).items())),
+        }
+        if split != "quarantine":
+            samples = balanced_samples(rows)
+            (output / "samples" / f"{split}.jsonl").write_text(
+                "".join(json.dumps(clean_record(row), ensure_ascii=False) + "\n" for row in samples), encoding="utf-8"
+            )
+            sample_manifest["splits"][split] = {"rows": len(samples), "sources": sorted({row["source"] for row in samples})}
+    provenance = []
+    used_metadata = set()
+    for record in sorted(records, key=lambda item: item["id"]):
+        identities = [record, *record["_aliases"]]
+        used_metadata.update(item["id"] for item in identities)
+        text = record["text"]
+        provenance.append({
+            "id": record["id"], "source": record["source"], "input_path": record["_input_path"],
+            "text_sha256": record["_text_sha256"], "raw_text_sha256": sha256(text),
+            "license": record["license"], "author": record["author"], "created": record["created"],
+            "token_count": record["token_count"], "split": record["_split"],
+            "group_id": record["_group_id"], "group_aliases": record["_group_keys"],
+            "duplicate_input_identities": record["_aliases"], "exclusion_reasons": record["_exclusion_reasons"],
+            "quality_flags": [name for name, present in (
+                ("unicode_replacement_character", "\ufffd" in text),
+                ("private_use_glyphs", any("\ue000" <= character <= "\uf8ff" for character in text)),
+            ) if present],
+        })
+    (output / "provenance/records.jsonl").write_text(
+        "".join(json.dumps(item, ensure_ascii=False) + "\n" for item in provenance), encoding="utf-8"
+    )
+    (output / "provenance/source_metadata.jsonl").write_text(
+        "".join(json.dumps({"id": identity, "metadata": metadata[identity]}, ensure_ascii=False) + "\n" for identity in sorted(used_metadata)), encoding="utf-8"
+    )
+    active = [row for row in records if row["_split"] != "quarantine"]
+    quarantine = split_records["quarantine"]
+    reasons = Counter(reason for row in quarantine for reason in row["_exclusion_reasons"])
+    manifest = {
+        "dataset": "Polish technical mega DynaWord", "version": policy["version"], "language": ["pl"],
+        "schema": SCHEMA.names, "base_hub_revision": policy["base_hub_revision"],
+        "layout": {"train": "data/train.parquet", "valid": "data/validation.parquet", "test": "data/test.parquet", "quarantine": "quarantine/records.parquet"},
+        "scope": policy["selected_scope"], "proxy_tokenizer": "cl100k_base",
+        "documents": len(active), "tokens": sum(row["token_count"] for row in active),
+        "sources": {source: {"documents": count} for source, count in sorted(Counter(row["source"] for row in active).items())},
+        "splits": {split: split_manifest[split] for split in ("train", "valid", "test")},
+        "quarantine": {**split_manifest["quarantine"], "reasons": dict(sorted(reasons.items()))},
+        "conservation": {**baseline_check, "retained_records": len(active), "quarantined_records": len(quarantine)},
+        "deduplication": "Exact whitespace-normalized casefolded text; duplicate provenance aliases join the same group.",
+        "split_policy": "SHA256 of canonical document/book alias component; <5 test, <10 valid, otherwise train. Biblioteka uses original numeric article-ID seeds.",
+        "source_policy": "Original attribution and per-record licences preserved; no blanket relicensing. Metadata labels are not independent legal clearance.",
+        "limitations": ["Near-duplicate and semantic overlap are not ruled out.", "Source facts and all OCR text have not been manually validated.", "Existing model pretraining contamination is not ruled out."],
+        **stats,
+    }
+    json_file(output / "manifest.json", manifest)
+    json_file(output / "samples/manifest.json", sample_manifest)
+    json_file(output / "quarantine/manifest.json", manifest["quarantine"])
+    json_file(output / "provenance/build_report.json", {"base_hub_revision": policy["base_hub_revision"], **baseline_check, **stats, "retained_records": len(active), "quarantined_records": len(quarantine), "exclusion_reasons": dict(reasons), "quality_flags": dict(Counter(flag for item in provenance for flag in item["quality_flags"]))})
+    json_file(output / "processing/technical_mega_curation_policy.json", policy)
+    for name in ("build_polish_technical_mega_dynaword.py", "technical_corpus_curation.py", "pack_cnc_slayer.py", "validate_cnc_dynaword.py", "validate_technical_mega.py"):
+        shutil.copy2(Path(__file__).with_name(name), output / "processing" / name)
+    (output / "licenses/SOURCES.md").write_text(
+        "# Source and licence policy\n\nEach row preserves its original licence and author. "
+        "`provenance/source_metadata.jsonl` preserves source URLs, attribution, book memberships and available checksums. "
+        "Join by record ID, including duplicate identities recorded in `provenance/records.jsonl`. "
+        "Follow each original licence, including attribution/share-alike requirements. No blanket relicensing or independent rights clearance is claimed.\n\n"
+        "Historical scans, out-of-scope books and a verified damaged article are preserved in `quarantine/records.parquet`; they are not default training data. "
+        "Per-record exclusions and quality flags are in provenance. Missing OCR words are never guessed.\n", encoding="utf-8"
+    )
+    (output / "README.md").write_text(
+        "---\nlicense: other\nlicense_name: per-record\nlanguage:\n- pl\npretty_name: Polish technical mega DynaWord\n"
+        "task_categories:\n- text-generation\nlibrary_name: datasets\nsize_categories:\n- 10K<n<100K\ntags:\n- polish\n- technical\n- cnc\n- automation\n- dynaword\nconfigs:\n- config_name: default\n  data_files:\n  - split: train\n    path: data/train.parquet\n  - split: validation\n    path: data/validation.parquet\n  - split: test\n    path: data/test.parquet\n---\n\n"
+        "# Polish technical mega DynaWord — repaired v0.3.0\n\n"
+        "Polski korpus techniki i nauk ścisłych: przemysł, CNC, automatyka, informatyka, matematyka, fizyka i chemia. "
+        "To teksty dokumentów, nie zbiór instrukcji do chatbota ani zatwierdzone procedury obsługi maszyn.\n\n"
+        "## What changed\n\n"
+        "Chunks of one article/book now share one split. Shared PDF checksums, alternate source identities, ZPE page IDs and overlapping AGH book memberships are joined transitively. "
+        "Wikibooks selection is an explicit review of book titles, not keyword deletion inside chapters. "
+        "Out-of-scope content, historical technical scans and verified damaged article 103741 are preserved in quarantine with reasons. "
+        "Text is not rewritten or completed by a language model. Samples cover source families rather than just the first alphabetic source.\n\n"
+        f"Baseline revision: `{policy['base_hub_revision']}`. All {len(records):,} original unique records remain accounted for: "
+        f"**{len(active):,} retained**, **{len(quarantine):,} quarantined**. "
+        "The previous revision remains available in repository history and under `pre-repair-0.3.0`.\n\n"
+        "| Split | Text chunks | Document/book groups | Proxy tokens (`cl100k_base`) |\n|---|---:|---:|---:|\n"
+        + "\n".join(f"| {split} | {value['documents']} | {value['document_groups']} | {value['tokens']} |" for split, value in split_manifest.items())
+        + "\n\n## Files and reproducibility\n\n"
+        "`data/*.parquet` keeps the eight-column DynaWord schema. The explicit default config excludes quarantine. "
+        "`provenance/records.jsonl` maps every retained/quarantined record to a document group, content hashes, aliases, exclusion reasons and quality flags. "
+        "`provenance/source_metadata.jsonl` preserves original attribution. `processing/` contains the builder, explicit curation policy, packer and validators; "
+        "rebuilding requires the original local source layers/metadata referenced by the builder, which are not all standalone Hub datasets. "
+        "The published validation report checks the delivered artifacts without downloading original PDFs.\n\n"
+        "`slayer_v6/` contains freshly regenerated little-endian uint16 native Slayer tokens, EOS 0 after each chunk and uint64 end offsets; see its manifest for exact token counts and tokenizer SHA256. "
+        "`manifest.json` counts are **proxy tokens**, not native Slayer token counts.\n\n"
+        "## Limits and training use\n\n"
+        "Group-disjoint splitting prevents the identified document/chunk leakage, not every near-duplicate, semantic overlap or pretraining contamination. "
+        "All source text has not received expert factual/OCR review; remaining Unicode quality flags are explicit. Historical text is not current operating guidance. "
+        "Licence metadata is retained, not independently cleared. Observe original attribution/share-alike terms.\n\n"
+        "**Do not compare old and new validation curves as if the holdout were unchanged.** "
+        "Do not reuse old dataloader offsets with these regenerated packs. A model already trained on old held-out material does not regain an unseen test set through repartitioning.\n",
+        encoding="utf-8",
+    )
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, default=DATASET)
+    parser.add_argument("--baseline", type=Path, default=ROOT / "data/polish_technical_mega_dynaword")
+    parser.add_argument("--policy", type=Path, default=POLICY)
+    args = parser.parse_args()
+    if args.output.exists():
+        raise FileExistsError(f"Refusing to overwrite existing output: {args.output}")
+    policy = json.loads(args.policy.read_text(encoding="utf-8"))
+    records, stats, _ = load_records()
+    baseline_check = assert_baseline(records, args.baseline)
+    metadata = load_metadata(ROOT / "data")
+    manifest = write_dataset(records, stats, metadata, policy, args.output, baseline_check)
+    from pack_cnc_slayer import pack
+    pack(args.output, args.output / "slayer_v6", ROOT / "models/Slayer1B-1.06/tokenizer.json", "PiotrSty/polish-technical-mega-dynaword")
+    print(json.dumps({"output": str(args.output), "documents": manifest["documents"], "quarantine": manifest["quarantine"]["documents"], "splits": manifest["splits"]}, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

processing/pack_cnc_slayer.py

@@ -0,0 +1,98 @@
+"""Pack DynaWord-compatible CNC Parquet into Slayer uint16/doc-index files."""
+from __future__ import annotations
+
+import argparse
+from array import array
+import hashlib
+import json
+from pathlib import Path
+import shutil
+import struct
+import sys
+
+import pyarrow.parquet as pq
+from tokenizers import Tokenizer
+
+ROOT = Path(__file__).resolve().parents[1]
+INPUT_DIRS = {"train": "data/train.parquet", "valid": "data/validation.parquet", "test": "data/test.parquet"}
+OUTPUT_DIRS = {"train": "train", "valid": "valid", "test": "test"}
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1 << 20), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def pack_split(input_root: Path, output_root: Path, split: str, tokenizer: Tokenizer) -> dict:
+    parquet_file = input_root / INPUT_DIRS[split]
+    if not parquet_file.is_file():
+        raise FileNotFoundError(f"missing Parquet file for {split}: {parquet_file}")
+    parquet_files = [parquet_file]
+    output_root.mkdir(parents=True, exist_ok=True)
+    bin_path = output_root / "train.bin"
+    if split != "train":
+        bin_path = output_root / f"{split}.bin"
+    idx_path = output_root / "docs.idx"
+    documents = 0
+    tokens = 0
+    with bin_path.open("wb") as bin_file, idx_path.open("wb") as idx_file:
+        offset = 0
+        for parquet_path in parquet_files:
+            table = pq.read_table(parquet_path, columns=["id", "text"])
+            for record_id, text in zip(table["id"].to_pylist(), table["text"].to_pylist()):
+                ids = tokenizer.encode(text).ids
+                if any(token_id > 65535 for token_id in ids):
+                    raise ValueError(f"token id exceeds uint16 for {record_id}")
+                values = array("H", ids)
+                values.append(0)
+                if sys.byteorder != "little":
+                    values.byteswap()
+                if values.itemsize != 2:
+                    raise RuntimeError("uint16 packing requires two-byte unsigned array items")
+                bin_file.write(values.tobytes())
+                offset += len(values)
+                idx_file.write(struct.pack("<Q", offset))
+                documents += 1
+                tokens += len(values)
+    return {"documents": documents, "tokens_including_eos": tokens, "bin_sha256": sha256(bin_path), "idx_sha256": sha256(idx_path)}
+
+
+def pack(input_root: Path, output_root: Path, tokenizer_path: Path, dataset_name: str) -> dict:
+    tokenizer = Tokenizer.from_file(str(tokenizer_path))
+    if tokenizer.token_to_id("<|endoftext|>") != 0:
+        raise ValueError("expected Slayer EOS token <|endoftext|> to have id 0")
+    output_root.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(tokenizer_path, output_root / "tokenizer.json")
+    stats = {}
+    for split in INPUT_DIRS:
+        stats[split] = pack_split(input_root, output_root / OUTPUT_DIRS[split], split, tokenizer)
+    manifest = {
+        "dataset": dataset_name,
+        "version": json.loads((input_root / "manifest.json").read_text(encoding="utf-8")).get("version", "0.1.0"),
+        "format": "little-endian uint16 token ids; one EOS token 0 after every document",
+        "index": "little-endian uint64 document end offsets in tokens including EOS",
+        "tokenizer": "Slayer1B-1.06 tokenizer.json",
+        "tokenizer_sha256": sha256(tokenizer_path),
+        "vocab_size": tokenizer.get_vocab_size(),
+        "eos_id": 0,
+        "source": "../data/{train,validation,test}.parquet",
+        "splits": stats,
+    }
+    (output_root / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    return manifest
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dataset-name", default="CNC/CAM Slayer pretraining pack")
+    parser.add_argument("--input", type=Path, default=ROOT / "data" / "cnc_dynaword")
+    parser.add_argument("--output", type=Path, default=ROOT / "data" / "cnc_dynaword" / "slayer_v6")
+    parser.add_argument("--tokenizer", type=Path, default=ROOT / "models" / "Slayer1B-1.06" / "tokenizer.json")
+    args = parser.parse_args()
+    print(json.dumps(pack(args.input, args.output, args.tokenizer, args.dataset_name), ensure_ascii=False, indent=2))
+
+if __name__ == "__main__":
+    main()

processing/technical_corpus_curation.py

@@ -0,0 +1,159 @@
+"""Document-level curation; no language-model inference or invented OCR corrections."""
+from __future__ import annotations
+
+from collections import defaultdict, deque
+import hashlib
+import json
+from pathlib import Path
+import re
+from urllib.parse import urlparse
+
+POLICY = Path(__file__).with_name("technical_mega_curation_policy.json")
+
+
+def load_metadata(root: Path) -> dict[str, list[dict]]:
+    paths = [root / "polish_cnc_technical_dynaword/provenance" / name for name in (
+        "full_source_records.jsonl", "augmentation_bcpw_records.jsonl",
+        "augmentation_zpe_records.jsonl", "augmentation_rock_records.jsonl",
+    )]
+    paths += [root / folder / "provenance/articles.jsonl" for folder in (
+        "polish_industrial_maintenance_dynaword", "polish_automation_control_dynaword",
+        "polish_engineering_new_dynaword",
+    )]
+    paths.append(root / "zpe_cnc_pl_dynaword/provenance/records.jsonl")
+    paths += sorted((root / "polish_source_subset/data").glob("*/*.attribution.jsonl"))
+    result: dict[str, list[dict]] = defaultdict(list)
+    for path in paths:
+        for line in path.read_text(encoding="utf-8-sig").splitlines():
+            if line.strip():
+                metadata = json.loads(line)
+                if metadata not in result[metadata["id"]]:
+                    result[metadata["id"]].append(metadata)
+    return dict(result)
+
+
+def group_keys(record: dict, metadata: list[dict]) -> list[str]:
+    """Aliases join shared PDFs, book chapters and alternate source namespaces."""
+    source, identity = record["source"], record["id"]
+    keys = set()
+    for item in metadata:
+        if source.startswith("bibliotekanauki-"):
+            article = str(item["article_id"])
+            keys.add("bibliotekanauki:" + article)
+        elif source == "wikibooks":
+            keys.add("wikibooks:" + item["title"].split("/", 1)[0])
+        elif source == "open_agh_chemistry_pl":
+            keys.update("agh-book:" + str(book["book_id"]) for book in item["memberships"])
+        elif source in ("rock_pollub_pl", "rock-pollub-open"):
+            handle = item["handle"].removeprefix("https://hdl.handle.net/").strip("/")
+            keys.add("rock-book:" + handle)
+        elif source == "open_icm_pl":
+            keys.add("icm-book:" + item["handle"].removeprefix("https://hdl.handle.net/").strip("/"))
+        elif source == "bcpw-public-domain":
+            keys.add("bcpw-book:" + " ".join(item["title"].split()).casefold())
+        elif source == "wikisource-maszynisci-1873":
+            keys.add("wikisource-book:maszynisci-1873")
+        elif source == "zpe-cnc-pl":
+            page = urlparse(item["url"]).path.rstrip("/").rsplit("/", 1)[-1]
+            if not re.fullmatch(r"D[A-Za-z0-9]+", page):
+                raise ValueError(f"Unreviewed ZPE page identity: {identity}: {page}")
+            keys.add("zpe-page:" + page)
+        else:
+            raise ValueError(f"Unreviewed source family: {source}")
+        for digest in (item.get("pdf_sha256"), item.get("payload_sha256"), (item.get("pdf") or {}).get("sha256")):
+            if digest:
+                if not re.fullmatch(r"[0-9a-f]{64}", digest):
+                    raise ValueError(f"Invalid PDF checksum: {identity}")
+                keys.add("pdf:" + digest)
+    if not keys:
+        raise ValueError(f"Missing document/book attribution: {identity}")
+    return sorted(keys)
+
+
+def exclusion_reasons(record: dict, metadata: list[dict], policy: dict) -> list[str]:
+    source = record["source"]
+    reasons = set()
+    if source == "wikibooks":
+        for item in metadata:
+            book = item["title"].split("/", 1)[0]
+            decision = policy["wikibooks_books"][book]  # Unknown books require review.
+            if not decision["include"]:
+                reasons.add("outside_selected_book_scope")
+    if source == "open_icm_pl" and record["id"] not in policy["open_icm_include_ids"]:
+        reasons.add("outside_selected_book_scope")
+    if source in ("bcpw-public-domain", "wikisource-maszynisci-1873"):
+        reasons.add("historical_technical_archive_not_current_training")
+    if source.startswith("bibliotekanauki-"):
+        for item in metadata:
+            reviewed = policy["reviewed_damaged_articles"].get(str(item["article_id"]))
+            if reviewed:
+                if item["pdf_sha256"] != reviewed["pdf_sha256"]:
+                    raise ValueError("Reviewed damaged PDF changed; a new review is required")
+                reasons.add("verified_unreliable_pdf_text_layout")
+    return sorted(reasons)
+
+
+def assign_groups(records: list[dict], metadata: dict[str, list[dict]], policy: dict) -> None:
+    parents: dict[str, str] = {}
+
+    def find(key: str) -> str:
+        parents.setdefault(key, key)
+        root = key
+        while parents[root] != root:
+            root = parents[root]
+        while parents[key] != key:
+            next_key = parents[key]
+            parents[key] = root
+            key = next_key
+        return root
+
+    for record in records:
+        identities = [record, *record.get("_aliases", [])]
+        keys = sorted({key for identity in identities for key in group_keys(identity, metadata[identity["id"]])})
+        root = find(keys[0])
+        for key in keys[1:]:
+            other = find(key)
+            if other != root:
+                low, high = sorted((root, other))
+                parents[high] = low
+                root = low
+        record["_group_keys"] = keys
+        record["_exclusion_reasons"] = sorted({
+            reason for identity in identities
+            for reason in exclusion_reasons(identity, metadata[identity["id"]], policy)
+        })
+    group_reasons: dict[str, set[str]] = defaultdict(set)
+    for record in records:
+        record["_group_id"] = find(record["_group_keys"][0])
+        group_reasons[record["_group_id"]].update(record["_exclusion_reasons"])
+    for record in records:
+        record["_exclusion_reasons"] = sorted(group_reasons[record["_group_id"]])
+        record["_split"] = "quarantine" if record["_exclusion_reasons"] else split_for(record["_group_id"])
+
+
+def split_for(group: str) -> str:
+    # Preserve the original article-ID split algorithm for unaliased Biblioteka articles.
+    seed = group.removeprefix("bibliotekanauki:") if group.startswith("bibliotekanauki:") else group
+    bucket = int(hashlib.sha256(seed.encode("utf-8")).hexdigest()[:8], 16) % 100
+    return "test" if bucket < 5 else "valid" if bucket < 10 else "train"
+
+
+def balanced_samples(records: list[dict], limit: int = 32) -> list[dict]:
+    """Round robin across source families; distinct books/documents first."""
+    buckets: dict[str, list[dict]] = defaultdict(list)
+    for record in sorted(records, key=lambda row: hashlib.sha256(row["id"].encode()).hexdigest()):
+        buckets[record["source"]].append(record)
+    queues = {}
+    for source, rows in sorted(buckets.items()):
+        seen = set()
+        first, rest = [], []
+        for row in rows:
+            (rest if row["_group_id"] in seen else first).append(row)
+            seen.add(row["_group_id"])
+        queues[source] = deque(first + rest)
+    sample = []
+    while len(sample) < limit and any(queues.values()):
+        for queue in queues.values():
+            if queue and len(sample) < limit:
+                sample.append(queue.popleft())
+    return sample

processing/technical_mega_curation_policy.json

@@ -0,0 +1,1639 @@
+{
+  "version": "0.3.0",
+  "selected_scope": "Technology, engineering, mathematics, physics, chemistry and computing; user-selected scope.",
+  "base_hub_revision": "66ea025cb1b47bdc08df2e4bed10c091a62a4f8c",
+  "wikibooks_books": {
+    "Action Script": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Adobe Flex": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Aktualizacja i kompilacja jądra w Debianie": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Akwarium": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Algebra abstrakcyjna": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Algebra liniowa": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Algorytmy": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Allegro": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Analiza matematyczna": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Analiza rzeczywista": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Aneks": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Angielski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Aptosid - czyli Debian sid krok po kroku dla każdego": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Arabski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Asembler": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Asembler X86": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Asembler x86": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Asertywność": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Astrofizyka": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Astronomiczne podstawy geografii": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Atari BASIC": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Atlas flory Polski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Atlas histopatologii guzów skóry": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Aurox": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "AutoIt": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Axiom": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "BIOS": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Bash": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "BasicC": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Baskijski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Bazy danych": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "BeOS dla użytkowników Linuksa": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Bezpieczeństwo motocyklisty na drodze": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Bezprzewodowy sprzęt sieciowy": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Biochemia": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Biologia dla liceum": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Biologia dla szkoły podstawowej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Biologia szkoła ponadgimnazjalna": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Bitcoin": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Blitz3D": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Borland C++ Compiler": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Brudnopis Wikipedysty:Tomekg.966": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Brudnopis wikipedysty:Kabexxxior": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Brydż": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Brydżowe tablice prawdopodobieństwa": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "C": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "C Sharp": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "C++": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "CSS": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "CVS": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Chemia": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Chemia nieorganiczna": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Chemia organiczna": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Chiński": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Ciąg Fibonacciego": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Cocoa": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Colobot": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Common Lisp": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "CorelDRAW": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Cryptsetup": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Cyfrowe filmowanie": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Czeski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "D": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Darmowe oprogramowanie": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Debian": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Debian - uniwersalna instalacja": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Debian dla Acer Aspire 502x": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Dekomunizacja w Polsce po 1989 roku": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Delphi": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Delphi i nie tylko. Efektywne programowanie": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Depilacja": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Dieta wegańska": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Dinozaury": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "DirectX": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Dixielandowe Przepisy Ciotki Karoliny": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Dobre wychowanie dla osób ze spektrum autyzmu": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Droga Polski do Unii Europejskiej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Dyne:bolic": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Dzieje i funkcjonowanie PZPR (1948–1990)": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "EasyCASE - Projektowanie baz danych": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Edukacja zdrowotna": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Ekoogrodnictwo": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Elektrodynamika klasyczna": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Elementarna teoria liczb": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Emacs": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Esperanto": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Estoński": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Etyka dla szkoły podstawowej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "FTP": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Fale": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Fałszywi przyjaciele slawisty": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Fdisk": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Fedora Core 6 w przykładach": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Filozofia": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Fizyka dla gimnazjum": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Fizyka dla liceum": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Fizyka statystyczna": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Fizyka teoretyczna": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Fiński": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Flex i Bison": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Fortran": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Fotografia": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Francuski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "FreeBSD": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Fretki": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Fryzjerstwo": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "GIMP": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "GNU Octave": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "GTK+": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Genealogia Piastów": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Geografia dla gimnazjum": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Geografia dla liceum": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Git": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "GnuPG": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Gnuplot": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Gramatyka języka słowackiego": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Gry karciane": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Grzyby Polski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Górnołużycki": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "HTML": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Haskell": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Hello World w konsoli": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Hindi": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Historia Polski 1914-1939": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Historia białostockich ulic": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Historia dla klas 7-8 szkoły podstawowej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Historia konstytucji w Polsce": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Historia powszechna": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Hiszpański": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Hiszpański:Lekcja A0": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "IRC": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Icon": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Indonezyjski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Informatyka dla klas 7-8 szkoły podstawowej": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Informatyka dla szkoły podstawowej": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Inkscape w praktyce": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Instalacja Debiana 3.1 sarge z płyty CD w trybie \"linux\" na architekturze i386": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Instalacja systemu Fedora-12 na macierzy RAID-1": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Interlingua": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Internet w praktyce": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Irrlicht": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Irssi": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Jabber": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Jak się uczyć z SuperMemo?": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Jak zapobiegać chorobom – higiena, szczepienia, właściwe nawyki": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Jak zrobić dobry zielnik": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Jak żyć oszczędnie": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Jak żyć z HCV": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Japoński": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Japoński:Podstawy Lekcja 1:Odpowiedzi": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Java": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Java - Myśleć jak programista": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Java - proste aplikacje": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "JavaScript": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Jidysz": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Kangur - międzynarodowy test z matematyki": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Kaszubski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Kate OS": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Keyboard": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Kody źródłowe": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Kolędy": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Komputer w praktyce": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Komputery": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Koncepcje programowania": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Konkurs Piosenki Eurowizji": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Konstytucja Rzeczypospolitej Polskiej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Koreański": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Książka kucharska": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Kurczaczek wielkanocny": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "LILO": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "LaTeX": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Lawiny": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Legenda – jak czytać znaki na planie i mapie": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Libertarianizm": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Liczby pierwsze": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Liczby zespolone": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Lingwa de Planeta": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Linux": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Linux - wprowadzenie": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Linux Mint": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Linux w sx1": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Lisp": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Litewski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Logika dla prawników": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Logika i teoria mnogości": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Lożban": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "MS-DOS": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Magnetyczny rezonans jądrowy w chemii organicznej": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Mandrake Linux": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Mandriva": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Mandriva 2006": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Matematyka dla klas 7-8 szkoły podstawowej": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Matematyka dla liceum": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Matematyka dla ostatnich klas szkoły podstawowej": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Matematyka dla szkoły podstawowej": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Matematyka ubezpieczeń życiowych": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Materiały do nauk administracyjnych": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Matura 2010": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Maxima": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Mechanika kwantowa": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Mechanika teoretyczna": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "MediaWiki w obrazkach": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Metody matematyczne fizyki": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Metody numeryczne fizyki": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Microsoft Office 2007": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Microsoft Office 2010": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Microsoft Windows": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Microsoft Windows 9x": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Microsoft Windows NT": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "MikroTik Router OS": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "MikroTik na platformie WRAP": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Mikrobiologia": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Ministrant": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "ModPlug Tracker": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Muzyka": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Mykowirusy – wirusy infekujące grzyby": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Mózg jak komputer": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Napary": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Narodowy Bank Polski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Nauka gry na gitarze": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Niderlandzki": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Niemiecki": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Niemiecki dla klas 7-8 szkoły podstawowej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Notacja West-East i Bin": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Novial": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "OCaml": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "OGRE": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Object Pascal": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Od lamera do hakera": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Ogólna teoria względności": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Olfaktometria": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Onomastyka": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "OpenGL Shading Language": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "OpenOffice.org": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "OpenStreetMap": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Operacje na stringach w konsoli": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Optymalizacja systemu Windows XP": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Order Orła Białego": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Organiczna technika studiowania": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Origami": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Otwarty System Archiwizacji OSA: Podręcznik użytkownika": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "PC jako ruter lub serwer": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "PHP": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "POSIX Threads": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Pacyfikacja strajku w kopalni „Wujek”": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Pantelikon - Maraton – Kreta z komentarzem": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Pałac pamięci": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Perl": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Pisanie OS": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Pisownia Wschodniej Azji": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Piwowarstwo domowe": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Pliki wsadowe": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Podkasting. porady dla początkujących": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Podstawowe komponenty komputera": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Podstawy turystyki": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Polski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Polskie tańce narodowe": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Polszczyzna": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Pomocnik olimpijczyka - Elementy wiedzy obywatelskiej i ekonomicznej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Poradnik harcerski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Poradnik masażu": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Porozumieć się bez przemocy": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Powtarzamy matematykę - matura 2010": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Powtarzamy matematykę - matura 2011": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Pppd": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Prawo karne": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Procedury składowane w PostgreSQL": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Proces legislacyjny w Polsce": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Processing": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Programowanie": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Programowanie C++ Qt4 w systemie Gnu-Linux": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Programowanie komputerów": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Programowanie w MCML": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Programowanie w systemie UNIX": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Programowanie:Programowanie w Linuksie": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Pruski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Przewodnik po OZE": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Przewodnik po instalacji Debiana 3.0": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Prześladowania esperantystów w III Rzeszy i ZSRR": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Przybornik harcmistrza": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Przybornik nauczyciela": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Przyroda": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Psychologia dla wybranych kierunków zawodowych": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Pszczelarstwo": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Płatnik": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "QCad CE - podręcznik użytkownika": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "QElectroTech - Pierwsze kroki": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "R (język programowania)": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Rachunkowość": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "ReactOS": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Reforma języka polskiego z 1 stycznia 2026": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Rosyjski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Routing dynamiczny": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Rozbudowa komputera w praktyce": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Rozmówki polsko-ukraińskie": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Rośliny trujące i zwierzęta jadowite – rozpoznawanie i zasady ostrożności": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Ruby": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Rummikub": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Rumuński": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "SIP": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "SQL": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "SVG": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Sakrament małżeństwa w perspektywie życia wiecznego": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Samba": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Sejm Rzeczypospolitej Polskiej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Sieci P2P": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Sieci w Linuksie": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Siewki roślin flory Polski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Siewki roślin uprawianych w Polsce": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Silnia": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Silniki tłokowe o spalaniu wewnętrznym": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Silotski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Simpletest": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Slovio": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Smartmontools": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Sony Vegas": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Sony Vegas 9.0": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Sosy": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Starożytność": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Statyka budowli": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Statystyka": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Statystyka matematyczna": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Stdarg.h": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Steganografia cyfrowa": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Streszczenia obowiązkowych lektur szkolnych dla szkoły podstawowej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Streszczenia obowiązkowych lektur szkolnych dla szkół ponadpodstawowych": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Struktury danych": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Substancje sprężyste, kruche i plastyczne – przykłady z otoczenia i ich zastosowanie": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Subversion": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Sygnalizacja kolejowa": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Szachy": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Szczególna teoria względności": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Szlak Architektury Drewnianej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Szwedzki": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Tablica kwadratów": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Tablica rozkładu Cauchy'ego": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Tablica rozkładu F Snedecora": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Tablica rozkładu chi-kwadrat": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Tablica rozkładu normalnego": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Tablica rozkładu t-Studenta": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Tablica rozkładów na sumę dwóch liczb pierwszych": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Tablica wartości krytycznych dla współczynnika korelacji rang Spearmana": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Tatry": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Techniki manipulacji psychologicznej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Teoria grup przemiennych": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Terapia zajęciowa": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Terminologia naukowa": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Think inside Bochs": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Topologia ogólna": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Transformacja systemowa w Polsce": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Tuvalu": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Tworzenie witryn i aplikacji internetowych - Podstawy": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Ubuntu": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Uciążliwość zapachowa": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Ukraiński": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Układ kostny – rola szkieletu i przykładowe kości": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Układ krwionośny – serce i krążenie krwi": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Układy analogowe": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Unicode": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "VHDL": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "VPN - Wirtualne Sieci Prywatne": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Vim": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Visual Basic": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "W świetle GNU": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "WML": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Wielowątkowość": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Wietnamski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Wikipedysts:Doles": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Wikizeszyt geograficzny": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Wikizeszyt historyczny": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Wikizeszyt klasy I-III": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Wilamowski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Wolna przedsiębiorczość": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Wprowadzenie do elektroniki": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Wspinaczka": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Współpraca smaku i węchu – proste doświadczenia": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Wstęp do fizyki atomu": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Wstęp do fizyki cząstek elementarnych": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Wstęp do fizyki jądra atomowego": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Wstępna charakterystyka bakteriofaga Serratia φOS10": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Wychowanie do życia w rodzinie": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Wymiana komponentu RAID-1 w systemie Fedora-12": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Wymiar sprawiedliwości w Rzeczypospolitej Polskiej": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Wytrzymałość materiałów": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Wzmacniacze operacyjne": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Węgierski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Władze Rzeczypospolitej Polskiej na uchodźstwie (1939–1990)": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "XHTML": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "XML": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "XML Schema": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Zabawnik": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Zabezpieczenie komputera": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Zanurkuj w Pythonie": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Zanurkuj w Pythonie 3": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Zastosowanie LED w oświetleniu": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Zatrudnianie osób głuchoniewidomych": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Zbiór zadań maturalnych": {
+      "include": true,
+      "reason": "selected_technical_or_exact_science_book"
+    },
+    "Zbrodnia katyńska": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Zioła i przyprawy": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Łacina": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Łemkowski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Śląski": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Śpiewnik": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Świadome śnienie": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    },
+    "Życie codzienne": {
+      "include": false,
+      "reason": "outside_selected_book_scope"
+    }
+  },
+  "open_icm_include_ids": [
+    "open_icm_pl_8c8e1344-c7b4-4247-962a-8fcd7c635f14"
+  ],
+  "reviewed_damaged_articles": {
+    "103741": {
+      "reason": "Unreliable PDF text layout; two independent parsers and layout-sorted extraction retain broken or duplicated words. No invented text repair.",
+      "pdf_sha256": "c5a451b2c095917b864acd7bbeeadcd754b20a1d896512d291273fd96ff33bff"
+    }
+  },
+  "historical_policy": "Preserve pre-1950 scanned technical books outside default training, in quarantine with full provenance. They are not current operating guidance.",
+  "quarantine_is_preserved": true,
+  "no_synthetic_text_repair": true
+}

processing/validate_cnc_dynaword.py

@@ -0,0 +1,70 @@
+"""Validate DynaWord Parquet schema and Slayer binary pack invariants."""
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import struct
+
+import pyarrow.parquet as pq
+import tiktoken
+
+ROOT = Path(__file__).resolve().parents[1]
+SCHEMA = ["id", "text", "source", "added", "created", "token_count", "license", "author"]
+SPLITS = {"train": "data/train.parquet", "valid": "data/validation.parquet", "test": "data/test.parquet"}
+PACK_DIRS = {"train": "train", "valid": "valid", "test": "test"}
+
+
+def validate(root: Path) -> dict:
+    cl100k = tiktoken.get_encoding("cl100k_base")
+    manifest = json.loads((root / "manifest.json").read_text(encoding="utf-8"))
+    result = {}
+    for split, relative in SPLITS.items():
+        parquet_files = [root / relative]
+        if not parquet_files[0].is_file():
+            raise ValueError(f"missing Parquet files for {split}")
+        rows = 0
+        tokens = 0
+        ids = set()
+        for parquet_path in parquet_files:
+            table = pq.read_table(parquet_path)
+            if table.column_names != SCHEMA:
+                raise ValueError(f"schema mismatch in {parquet_path}: {table.column_names}")
+            for row in table.to_pylist():
+                if row["id"] in ids:
+                    raise ValueError(f"duplicate id in {split}: {row['id']}")
+                ids.add(row["id"])
+                measured = len(cl100k.encode_ordinary(row["text"]))
+                if row["token_count"] != measured:
+                    raise ValueError(f"cl100k token mismatch for {row['id']}: {row['token_count']} != {measured}")
+                rows += 1
+                tokens += row["token_count"]
+        expected = manifest["splits"][split]
+        if rows != expected["documents"] or tokens != expected["tokens"]:
+            raise ValueError(f"Parquet manifest mismatch for {split}: {rows}/{tokens} vs {expected}")
+        pack_dir = root / "slayer_v6" / PACK_DIRS[split]
+        bin_name = "train.bin" if split == "train" else f"{split}.bin"
+        bin_path = pack_dir / bin_name
+        idx_path = pack_dir / "docs.idx"
+        raw_size = bin_path.stat().st_size
+        if raw_size % 2:
+            raise ValueError(f"binary token file is not uint16-sized: {bin_path}")
+        idx_raw = idx_path.read_bytes()
+        if len(idx_raw) != rows * 8:
+            raise ValueError(f"index count mismatch for {split}")
+        final_offset = struct.unpack_from("<Q", idx_raw, len(idx_raw) - 8)[0]
+        if final_offset * 2 != raw_size:
+            raise ValueError(f"final document offset mismatch for {split}")
+        result[split] = {"documents": rows, "parquet_tokens": tokens, "packed_tokens_including_eos": final_offset}
+    return result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", type=Path, default=ROOT / "data" / "cnc_dynaword")
+    args = parser.parse_args()
+    print(json.dumps(validate(args.root), ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

processing/validate_technical_mega.py

@@ -0,0 +1,164 @@
+"""Verify delivered mega-corpus content, split isolation, attribution and native packs."""
+from __future__ import annotations
+
+import argparse
+from collections import Counter
+import hashlib
+import json
+from pathlib import Path
+
+import numpy as np
+import pyarrow.parquet as pq
+import tiktoken
+from tokenizers import Tokenizer
+
+from pack_cnc_slayer import sha256 as file_sha256
+from technical_corpus_curation import assign_groups
+from validate_cnc_dynaword import SCHEMA, SPLITS, validate as validate_format
+
+
+def digest(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+def verify(root: Path, baseline: Path | None = None) -> dict:
+    result = {"format_validation": validate_format(root)}
+    manifest = json.loads((root / "manifest.json").read_text(encoding="utf-8"))
+    provenance_rows = [json.loads(line) for line in (root / "provenance/records.jsonl").read_text(encoding="utf-8").splitlines()]
+    provenance = {item["id"]: item for item in provenance_rows}
+    if len(provenance) != len(provenance_rows):
+        raise ValueError("Duplicate provenance identity")
+    metadata_rows = [json.loads(line) for line in (root / "provenance/source_metadata.jsonl").read_text(encoding="utf-8").splitlines()]
+    metadata = {item["id"]: item["metadata"] for item in metadata_rows}
+    if len(metadata) != len(metadata_rows):
+        raise ValueError("Duplicate source metadata identity")
+    policy = json.loads((root / "processing/technical_mega_curation_policy.json").read_text(encoding="utf-8"))
+    all_rows, seen_ids, seen_texts, seen_groups, seen_aliases = [], set(), set(), {}, {}
+    source_counts, rows_by_split = {}, {}
+    cl100k = tiktoken.get_encoding("cl100k_base")
+    for split, relative in {**SPLITS, "quarantine": "quarantine/records.parquet"}.items():
+        table = pq.read_table(root / relative)
+        if table.column_names != SCHEMA:
+            raise ValueError(f"Schema mismatch: {relative}")
+        rows = table.to_pylist()
+        rows_by_split[split] = rows
+        source_counts[split] = dict(sorted(Counter(row["source"] for row in rows).items()))
+        for row in rows:
+            identity, text = row["id"], row["text"]
+            normalized = digest(" ".join(text.split()).casefold())
+            if identity in seen_ids or normalized in seen_texts:
+                raise ValueError(f"Duplicate identity/content: {identity}")
+            seen_ids.add(identity)
+            seen_texts.add(normalized)
+            proof = provenance[identity]
+            if proof["split"] != split or proof["raw_text_sha256"] != digest(text) or proof["text_sha256"] != normalized:
+                raise ValueError(f"Text or split differs from provenance: {identity}")
+            for field in ("source", "license", "author", "created", "token_count"):
+                if proof[field] != row[field]:
+                    raise ValueError(f"Attribution/content mismatch: {identity}: {field}")
+            for alias in (proof["group_id"], *proof["group_aliases"]):
+                if alias in seen_aliases and seen_aliases[alias] != split:
+                    raise ValueError(f"Document/book alias crosses splits: {alias}")
+                seen_aliases[alias] = split
+            group = proof["group_id"]
+            seen_groups[group] = split
+            if (split == "quarantine") != bool(proof["exclusion_reasons"]):
+                raise ValueError(f"Exclusion reason/split mismatch: {identity}")
+            if split == "quarantine" and row["token_count"] != len(cl100k.encode_ordinary(text)):
+                raise ValueError(f"Quarantine proxy token mismatch: {identity}")
+            row["_aliases"] = proof["duplicate_input_identities"]
+            all_rows.append(row)
+        expected = manifest["quarantine"] if split == "quarantine" else manifest["splits"][split]
+        if len(rows) != expected["documents"] or sum(row["token_count"] for row in rows) != expected["tokens"]:
+            raise ValueError(f"Partition count mismatch: {split}")
+        if source_counts[split] != expected["sources"]:
+            raise ValueError(f"Source count mismatch: {split}")
+        if len({provenance[row["id"]]["group_id"] for row in rows}) != expected["document_groups"]:
+            raise ValueError(f"Document group count mismatch: {split}")
+        if split != "quarantine":
+            samples = [json.loads(line) for line in (root / f"samples/{split}.jsonl").read_text(encoding="utf-8").splitlines()]
+            lookup = {row["id"]: {field: row[field] for field in SCHEMA} for row in rows}
+            if len({row["id"] for row in samples}) != len(samples):
+                raise ValueError(f"Duplicate sample: {split}")
+            if any(lookup.get(row["id"]) != row for row in samples):
+                raise ValueError(f"Sample not in its split: {split}")
+            if len(source_counts[split]) <= 32 and {row["source"] for row in samples} != set(source_counts[split]):
+                raise ValueError(f"Samples omit available source families: {split}")
+    if seen_ids != set(provenance):
+        raise ValueError("Orphan or missing provenance")
+    assign_groups(all_rows, metadata, policy)
+    for row in all_rows:
+        proof = provenance[row["id"]]
+        if row["_group_id"] != proof["group_id"] or row["_split"] != proof["split"] or row["_exclusion_reasons"] != proof["exclusion_reasons"] or row["_group_keys"] != proof["group_aliases"]:
+            raise ValueError(f"Recomputed curation/group assignment differs: {row['id']}")
+    conservation = manifest["conservation"]
+    retained = sum(len(rows_by_split[split]) for split in SPLITS)
+    if len(all_rows) != conservation["records"] or retained != manifest["documents"] or len(rows_by_split["quarantine"]) != conservation["quarantined_records"] or retained != conservation["retained_records"]:
+        raise ValueError("Record conservation mismatch")
+    if sum(row["token_count"] for split in SPLITS for row in rows_by_split[split]) != manifest["tokens"]:
+        raise ValueError("Active corpus token total mismatch")
+    if baseline:
+        originals = [row for path in sorted((baseline / "data").glob("*.parquet")) for row in pq.read_table(path).to_pylist()]
+        fingerprints = lambda rows: {row["id"]: tuple(row[field] for field in SCHEMA) for row in rows}
+        if len(originals) != len(all_rows) or fingerprints(originals) != fingerprints(all_rows):
+            raise ValueError("Original records were lost, added or modified")
+    packed = json.loads((root / "slayer_v6/manifest.json").read_text(encoding="utf-8"))
+    tokenizer_file = root / "slayer_v6/tokenizer.json"
+    if file_sha256(tokenizer_file) != packed["tokenizer_sha256"]:
+        raise ValueError("Tokenizer checksum mismatch")
+    tokenizer = Tokenizer.from_file(str(tokenizer_file))
+    if tokenizer.token_to_id("<|endoftext|>") != 0 or tokenizer.get_vocab_size() != packed["vocab_size"] or packed["eos_id"] != 0 or packed["version"] != manifest["version"]:
+        raise ValueError("Tokenizer or pack version mismatch")
+    native_counts = {}
+    for split in SPLITS:
+        folder = root / "slayer_v6" / split
+        token_file, index_file = folder / f"{split}.bin", folder / "docs.idx"
+        expected = packed["splits"][split]
+        if file_sha256(token_file) != expected["bin_sha256"] or file_sha256(index_file) != expected["idx_sha256"]:
+            raise ValueError(f"Pack checksum mismatch: {split}")
+        tokens = np.fromfile(token_file, dtype="<u2")
+        offsets = np.fromfile(index_file, dtype="<u8")
+        rows = rows_by_split[split]
+        if len(offsets) != len(rows) or len(rows) != expected["documents"] or len(tokens) != expected["tokens_including_eos"]:
+            raise ValueError(f"Pack length mismatch: {split}")
+        if len(offsets) and (offsets[0] == 0 or np.any(offsets[1:] <= offsets[:-1]) or offsets[-1] != len(tokens)):
+            raise ValueError(f"Non-monotonic or incomplete document offsets: {split}")
+        if len(tokens) and int(tokens.max()) >= packed["vocab_size"]:
+            raise ValueError(f"Invalid vocabulary token: {split}")
+        start = 0
+        for row, end in zip(rows, offsets):
+            end = int(end)
+            if tokens[end - 1] != 0:
+                raise ValueError(f"Missing EOS: {row['id']}")
+            encoded = np.asarray(tokenizer.encode(row["text"]).ids, dtype="<u2")
+            if not np.array_equal(encoded, tokens[start:end - 1]):
+                raise ValueError(f"Packed tokens differ from exact reencoding: {row['id']}")
+            start = end
+        native_counts[split] = {"documents": len(rows), "tokens_including_eos": len(tokens), "exact_reencoded_documents": len(rows)}
+    artifact_paths = sorted(path for path in root.rglob("*") if path.is_file() and path.name != "validation_report.json" and ".cache" not in path.parts)
+    result.update({
+        "version": manifest["version"], "base_hub_revision": manifest["base_hub_revision"],
+        "records_accounted_for": len(all_rows), "retained_records": retained,
+        "quarantined_records": len(rows_by_split["quarantine"]),
+        "cross_split_group_aliases": 0, "exact_duplicate_texts": 0,
+        "baseline_all_eight_columns_preserved": baseline is not None,
+        "all_proxy_token_counts_verified": True,
+        "native_tokenizer_sha256": packed["tokenizer_sha256"], "native_packs": native_counts,
+        "sources_by_split": source_counts,
+        "artifacts": {str(path.relative_to(root)).replace("\\", "/"): file_sha256(path) for path in artifact_paths},
+    })
+    return result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, required=True)
+    parser.add_argument("--baseline", type=Path)
+    args = parser.parse_args()
+    result = verify(args.root, args.baseline)
+    (args.root / "provenance/validation_report.json").write_text(json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps({key: value for key, value in result.items() if key not in ("artifacts", "sources_by_split")}, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

provenance/build_report.json

@@ -1,9 +1,21 @@
 {
+  "base_hub_revision": "66ea025cb1b47bdc08df2e4bed10c091a62a4f8c",
+  "records": 22331,
+  "id_source_text_sha256_preserved": true,
   "input_files": 21,
   "input_rows": 24029,
   "duplicate_rows": 1698,
   "forbidden_license_rows": 0,
   "control_chars_removed": 5,
-  "output_rows": 22331,
-  "output_tokens": 40468328
+  "retained_records": 15809,
+  "quarantined_records": 6522,
+  "exclusion_reasons": {
+    "verified_unreliable_pdf_text_layout": 4,
+    "historical_technical_archive_not_current_training": 1546,
+    "outside_selected_book_scope": 4972
+  },
+  "quality_flags": {
+    "private_use_glyphs": 1992,
+    "unicode_replacement_character": 17
+  }
 }

provenance/source_metadata.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7de9cc42673cefde1effa1b03f077f2d8f0a49bb52501e340a62c17499d3e030
+size 18526305

provenance/validation_report.json

@@ -0,0 +1,114 @@
+{
+  "format_validation": {
+    "train": {
+      "documents": 13724,
+      "parquet_tokens": 25422631,
+      "packed_tokens_including_eos": 20255239
+    },
+    "valid": {
+      "documents": 940,
+      "parquet_tokens": 1822166,
+      "packed_tokens_including_eos": 1471326
+    },
+    "test": {
+      "documents": 1145,
+      "parquet_tokens": 4813267,
+      "packed_tokens_including_eos": 4382695
+    }
+  },
+  "version": "0.3.0",
+  "base_hub_revision": "66ea025cb1b47bdc08df2e4bed10c091a62a4f8c",
+  "records_accounted_for": 22331,
+  "retained_records": 15809,
+  "quarantined_records": 6522,
+  "cross_split_group_aliases": 0,
+  "exact_duplicate_texts": 0,
+  "baseline_all_eight_columns_preserved": true,
+  "all_proxy_token_counts_verified": true,
+  "native_tokenizer_sha256": "0640d3bd3674d7a6e59c540d945a2ad275a12e1bcaeb6007c37a90751f9815dd",
+  "native_packs": {
+    "train": {
+      "documents": 13724,
+      "tokens_including_eos": 20255239,
+      "exact_reencoded_documents": 13724
+    },
+    "valid": {
+      "documents": 940,
+      "tokens_including_eos": 1471326,
+      "exact_reencoded_documents": 940
+    },
+    "test": {
+      "documents": 1145,
+      "tokens_including_eos": 4382695,
+      "exact_reencoded_documents": 1145
+    }
+  },
+  "sources_by_split": {
+    "train": {
+      "bibliotekanauki-automation": 2015,
+      "bibliotekanauki-engineering-new": 4101,
+      "bibliotekanauki-maintenance": 2850,
+      "open_agh_chemistry_pl": 186,
+      "rock-pollub-open": 501,
+      "rock_pollub_pl": 7,
+      "wikibooks": 3479,
+      "zpe-cnc-pl": 585
+    },
+    "valid": {
+      "bibliotekanauki-automation": 144,
+      "bibliotekanauki-engineering-new": 354,
+      "bibliotekanauki-maintenance": 160,
+      "open_agh_chemistry_pl": 184,
+      "rock_pollub_pl": 1,
+      "wikibooks": 54,
+      "zpe-cnc-pl": 43
+    },
+    "test": {
+      "bibliotekanauki-automation": 99,
+      "bibliotekanauki-engineering-new": 301,
+      "bibliotekanauki-maintenance": 111,
+      "open_icm_pl": 1,
+      "rock-pollub-open": 68,
+      "wikibooks": 545,
+      "zpe-cnc-pl": 20
+    },
+    "quarantine": {
+      "bcpw-public-domain": 1398,
+      "bibliotekanauki-automation": 4,
+      "open_icm_pl": 10,
+      "wikibooks": 4962,
+      "wikisource-maszynisci-1873": 148
+    }
+  },
+  "artifacts": {
+    "data/test.parquet": "3f8d26726f02be90766be5366a2915eb7620cf098a921608e01bc1c8a7be04dc",
+    "data/train.parquet": "bb0f18cdf92494ab9d4fbb1910256d923189677c53771c3e6447b56dfad7aeca",
+    "data/validation.parquet": "cf75b249ae5add415926856833ddcfaa06f89665eefed739bd1275f9c8bccd51",
+    "licenses/SOURCES.md": "ea87dee75ec791001f9a24a1105bb20f7e052d54dc1b83c66e7e4da50c7ec809",
+    "manifest.json": "1e815f0406436c58d8c31eabe37d42241f25ae9ff090872d53ee283efc5818fb",
+    "processing/build_polish_technical_mega_dynaword.py": "9fb439ab7a4a5f95b7283fcd1063a096558e184d4ca2fac5b5c5ca0eecd971d5",
+    "processing/pack_cnc_slayer.py": "7e8a6107752bf42824887faed624c96e4a96064ed3a877ec661cb48af55f1688",
+    "processing/technical_corpus_curation.py": "35043dc25d580199718cc01205dd50382a52f30b276628c057089a6a2c30a185",
+    "processing/technical_mega_curation_policy.json": "10a371c0bffb9296edeb7be9332c432bce032ed78c4dd6abfba3657b5db564f8",
+    "processing/validate_cnc_dynaword.py": "d68895afd2d763e7ae4e4a155e284cc4d0633e7cdd4bf50c9ed3acd218d00838",
+    "processing/validate_technical_mega.py": "c2f03255b49b35abee879a245394e6f8b4fa662465d51a866d07f4da9d2941a6",
+    "provenance/build_report.json": "87b1ef2cd3db3b9e3a90d18e6d1d22f84d16eef75ee696a2b23c65bf370f8ebb",
+    "provenance/records.jsonl": "bfda0c4a22323a20822651c7ffe6f08981c04842eaf7d7a50dbd4fcdc0efacbb",
+    "provenance/source_metadata.jsonl": "7de9cc42673cefde1effa1b03f077f2d8f0a49bb52501e340a62c17499d3e030",
+    "quarantine/manifest.json": "900162e8d0069fb930d51c24586ae5ce15c6ed123dd624de4c9f151a7e14cb91",
+    "quarantine/records.parquet": "136134398e72ba7f9f533b370baa3f3e20357dd7d6d4aa00f9b3aa0605485e89",
+    "README.md": "9404df8faf83d45bc8ca1c1e883d7ee5ecea89c2dc3e1465e25d5ecab52a1642",
+    "samples/manifest.json": "e456b58eabd61c62513cf13343849dcab42a2ebc9313dbb29d62afe1e1d1b746",
+    "samples/test.jsonl": "72f12c24b4dc40685bf7d2b9e5adf82ca6275b0c5bab7f2d39d1b27e30bddc56",
+    "samples/train.jsonl": "18f8097af95c22dff12d03dd09b34e883dedd0a4595f6369f33462a3047a58d4",
+    "samples/valid.jsonl": "a99912d96c94b9db6b02f275808a64cac3379c061ba9304f2bef55a47cbea133",
+    "slayer_v6/manifest.json": "c2569c35128e028947634d11e38350a4a76b771bfe5e855f675cbeb017b917b7",
+    "slayer_v6/test/docs.idx": "ebdf996f57b1be0cf16a11975b2daf945a06c07ac6d322eff381cbb794682737",
+    "slayer_v6/test/test.bin": "4b6b8f33e73bc27db54e5842bb834ff804016a2eff199d78f9e5204faa43d116",
+    "slayer_v6/tokenizer.json": "0640d3bd3674d7a6e59c540d945a2ad275a12e1bcaeb6007c37a90751f9815dd",
+    "slayer_v6/train/docs.idx": "a173480e827899bf572e090422d536c665d056e26627de29d4193deb9295061c",
+    "slayer_v6/train/train.bin": "9e0e5a42080e56e9841799e8213e42140e10127d5071001b85ef1db96756adb5",
+    "slayer_v6/valid/docs.idx": "e8b30ab52946064c6570792ecc81c73ec0b6ad119d609601a62b8ed246778625",
+    "slayer_v6/valid/valid.bin": "ce9e491daec844853f69171304c34e4467d3290daf8d5137282cf57503fc6d2e"
+  }
+}

quarantine/manifest.json

@@ -0,0 +1,17 @@
+{
+  "documents": 6522,
+  "document_groups": 196,
+  "tokens": 8410264,
+  "sources": {
+    "bcpw-public-domain": 1398,
+    "bibliotekanauki-automation": 4,
+    "open_icm_pl": 10,
+    "wikibooks": 4962,
+    "wikisource-maszynisci-1873": 148
+  },
+  "reasons": {
+    "historical_technical_archive_not_current_training": 1546,
+    "outside_selected_book_scope": 4972,
+    "verified_unreliable_pdf_text_layout": 4
+  }
+}

quarantine/records.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:136134398e72ba7f9f533b370baa3f3e20357dd7d6d4aa00f9b3aa0605485e89
+size 9561981

samples/manifest.json

@@ -10,23 +10,43 @@
     "author"
   ],
   "max_rows": 32,
+  "method": "Round robin across sources, distinct document groups first",
   "splits": {
     "train": {
       "rows": 32,
       "sources": [
-        "bcpw-public-domain"
+        "bibliotekanauki-automation",
+        "bibliotekanauki-engineering-new",
+        "bibliotekanauki-maintenance",
+        "open_agh_chemistry_pl",
+        "rock-pollub-open",
+        "rock_pollub_pl",
+        "wikibooks",
+        "zpe-cnc-pl"
       ]
     },
     "valid": {
       "rows": 32,
       "sources": [
-        "bcpw-public-domain"
+        "bibliotekanauki-automation",
+        "bibliotekanauki-engineering-new",
+        "bibliotekanauki-maintenance",
+        "open_agh_chemistry_pl",
+        "rock_pollub_pl",
+        "wikibooks",
+        "zpe-cnc-pl"
       ]
     },
     "test": {
       "rows": 32,
       "sources": [
-        "bcpw-public-domain"
+        "bibliotekanauki-automation",
+        "bibliotekanauki-engineering-new",
+        "bibliotekanauki-maintenance",
+        "open_icm_pl",
+        "rock-pollub-open",
+        "wikibooks",
+        "zpe-cnc-pl"
       ]
     }
   }

slayer_v6/manifest.json

@@ -1,6 +1,6 @@
 {
-  "dataset": "Polish technical mega DynaWord 0.2.0 / Slayer1B 1.06",
-  "version": "0.2.0",
+  "dataset": "PiotrSty/polish-technical-mega-dynaword",
+  "version": "0.3.0",
   "format": "little-endian uint16 token ids; one EOS token 0 after every document",
   "index": "little-endian uint64 document end offsets in tokens including EOS",
   "tokenizer": "Slayer1B-1.06 tokenizer.json",
@@ -10,22 +10,22 @@
   "source": "../data/{train,validation,test}.parquet",
   "splits": {
     "train": {
-      "documents": 20095,
-      "tokens_including_eos": 28979777,
-      "bin_sha256": "4ac965a70862ef4e8c37b6eb7feb69ce3197998770d6126e85760088bfc19935",
-      "idx_sha256": "40e3f5ca241218b18e2cf0cecf7df9199bee2cce2de0ba2a371161899c9ebbb4"
+      "documents": 13724,
+      "tokens_including_eos": 20255239,
+      "bin_sha256": "9e0e5a42080e56e9841799e8213e42140e10127d5071001b85ef1db96756adb5",
+      "idx_sha256": "a173480e827899bf572e090422d536c665d056e26627de29d4193deb9295061c"
     },
     "valid": {
-      "documents": 1135,
-      "tokens_including_eos": 1712508,
-      "bin_sha256": "063ec64e8ae15d89f8327d02828b0dd32fdf19bb51033939f1fb81ecf33defe9",
-      "idx_sha256": "f4322280e173bfbbc9d0897c0ae457cf3c3b3c5afbd94957725ffcf7b09d29d2"
+      "documents": 940,
+      "tokens_including_eos": 1471326,
+      "bin_sha256": "ce9e491daec844853f69171304c34e4467d3290daf8d5137282cf57503fc6d2e",
+      "idx_sha256": "e8b30ab52946064c6570792ecc81c73ec0b6ad119d609601a62b8ed246778625"
     },
     "test": {
-      "documents": 1101,
-      "tokens_including_eos": 1659915,
-      "bin_sha256": "5cbdf9a5e4fd6b034a2b958c57f5da97e9f8c28f643b4d7a0bc994f3c141eca9",
-      "idx_sha256": "55c40a4de6f9798dc0590f66649ec71b7534e62e3f74319c71ac77d1c8ff8611"
+      "documents": 1145,
+      "tokens_including_eos": 4382695,
+      "bin_sha256": "4b6b8f33e73bc27db54e5842bb834ff804016a2eff199d78f9e5204faa43d116",
+      "idx_sha256": "ebdf996f57b1be0cf16a11975b2daf945a06c07ac6d322eff381cbb794682737"
     }
   }
 }

slayer_v6/test/test.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5cbdf9a5e4fd6b034a2b958c57f5da97e9f8c28f643b4d7a0bc994f3c141eca9
-size 3319830
+oid sha256:4b6b8f33e73bc27db54e5842bb834ff804016a2eff199d78f9e5204faa43d116
+size 8765390

slayer_v6/train/docs.idx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:40e3f5ca241218b18e2cf0cecf7df9199bee2cce2de0ba2a371161899c9ebbb4
-size 160760
+oid sha256:a173480e827899bf572e090422d536c665d056e26627de29d4193deb9295061c
+size 109792

slayer_v6/train/train.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4ac965a70862ef4e8c37b6eb7feb69ce3197998770d6126e85760088bfc19935
-size 57959554
+oid sha256:9e0e5a42080e56e9841799e8213e42140e10127d5071001b85ef1db96756adb5
+size 40510478

slayer_v6/valid/valid.bin

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:063ec64e8ae15d89f8327d02828b0dd32fdf19bb51033939f1fb81ecf33defe9
-size 3425016
+oid sha256:ce9e491daec844853f69171304c34e4467d3290daf8d5137282cf57503fc6d2e
+size 2942652