Add prose-repair pipeline implementation (10 stages, DMNR masking, typed repair, 6-tool quality ensemble)

repair_pipeline_package/__init__.py

@@ -0,0 +1,24 @@
+"""
+Ten-stage corpus data repair pipeline (Repair-First).
+
+Stage order strictly follows the paper, with the single mandatory modification:
+the "mixed-content masking" step is moved before "ftfy atomic repair"
+(i.e., the original Stage 3 is moved before the original Stage 2).
+
+Public entry point:
+    from repair_pipeline import RepairPipeline
+    out = RepairPipeline().run(raw_bytes, http_charset=..., source_hint=...)
+"""
+
+from .pipeline import RepairPipeline
+from .document import Document, AuditRecord, Segment, SegmentType
+
+__all__ = [
+    "RepairPipeline",
+    "Document",
+    "AuditRecord",
+    "Segment",
+    "SegmentType",
+]
+
+__version__ = "1.0.0"

repair_pipeline_package/config.py

@@ -0,0 +1,93 @@
+"""
+Central configuration: model paths, thresholds, constants.
+
+Every stage that needs an external model/dictionary reads its path from here.
+By convention, all models are placed under /data/models with descriptive
+placeholder filenames; put the real model files at the matching paths.
+"""
+
+import os
+
+# --------------------------------------------------------------------------- #
+# Models root directory
+# --------------------------------------------------------------------------- #
+MODELS_ROOT = os.environ.get("REPAIR_MODELS_ROOT", "/data/models")
+
+
+def _p(*parts: str) -> str:
+    return os.path.join(MODELS_ROOT, *parts)
+
+
+# --- Stages 2/3 masking: DOM Level-3 residual classifier + plain-text block classifier --- #
+XGB_AMBIGUOUS_BLOCK_MODEL = _p("masking", "dom_ambiguous_block_xgb.json")   # 42-dim XGBoost
+TEXT_BLOCK_ML_MODEL       = _p("masking", "text_block_lgbm.txt")            # lightweight ML block classifier
+
+# --- Code-type detection: Magika (pip-bundled model; optional override) -------- #
+MAGIKA_MODEL_DIR = _p("magika")   # leave empty to use the bundled magika model
+
+# --- Stage 5 line-level repair: custom spaCy model (complex sentence/line boundaries) --- #
+SPACY_LINEBREAK_MODEL = _p("spacy", "linebreak_repair_model")
+SPACY_FALLBACK_PIPE   = "en_core_web_sm"   # fallback when the custom model is missing
+
+# English dictionary (hyphen-wrap rejoin verification, SymSpell reuse) -------- #
+ENGLISH_WORDLIST = _p("dict", "english_words.txt")
+
+# --- Stage 8 OCR repair ------------------------------------------------------ #
+SYMSPELL_DICT_PATH        = _p("symspell", "frequency_dictionary_en_82_765.txt")
+SYMSPELL_BIGRAM_PATH      = _p("symspell", "frequency_bigramdictionary_en_243_342.txt")
+BYT5_OCR_MODEL_DIR        = _p("byt5-base-ocr-corrector")   # ByT5-base fine-tuned weights directory
+KENLM_MODEL_PATH          = _p("kenlm", "en.wiki.5gram.arpa.bin")   # perplexity scoring / rollback
+
+# --- Stage 9 quality validation: 6-tool complementary ensemble (CPU-only) ----- #
+DCLM_FASTTEXT_MODEL = _p("fasttext", "dclm_quality_classifier.bin")
+# NeMo-DataTrove-DataJuicer joint-metric system is rule/statistic-based: no separate weights file.
+# LanguageTool / NLTK / unicodedata / ftfy do not need any weights under /data/models.
+
+
+# --------------------------------------------------------------------------- #
+# Thresholds and constants
+# --------------------------------------------------------------------------- #
+
+# Stage 8 OCR: CER-tier routing boundaries (inclusive upper bounds)
+OCR_CER_SYMSPELL_MAX = 0.05   # < 5%   -> SymSpell
+OCR_CER_BYT5_MAX     = 0.15   # 5%-15% -> ByT5
+OCR_CER_ROLLBACK_MAX = 0.20   # 15%-20%-> ByT5 + KenLM rollback safety net
+# > 20% -> drop directly
+OCR_DICT_HIT_THRESHOLD = 0.90  # dictionary hit rate below this flags a suspected OCR-noise segment
+
+# Stage 5 line-level repair: fixed-column hard-wrap diagnostic
+FIXED_COLUMN_WIDTHS  = (72, 80)
+FIXED_COLUMN_TOL     = 4       # line lengths within column-width +/- 4 are treated as fixed-column layout
+
+# Stage 7 whitespace normalization
+TAB_TO_SPACES = 4
+MAX_CONSECUTIVE_BLANK_LINES = 2   # >=3 consecutive blank lines are collapsed to 2 (keeping 1 blank line)
+
+# Stage 9 quality gate: binary threshold (composite score >= threshold passes)
+QUALITY_PASS_THRESHOLD = 0.60
+
+# --------------------------------------------------------------------------- #
+# Private Use Area sentinels (PUA Sentinel)
+# --------------------------------------------------------------------------- #
+# We use the high PUA range to avoid common early-web font private-use blocks
+# (which typically begin at U+E000). Stage 6 PUA cleanup preserves sentinels
+# allocated within this range.
+SENTINEL_PUA_START = 0xF000     # sentinel allocation start codepoint
+SENTINEL_PUA_END   = 0xF8FF     # sentinel allocation end codepoint (PUA upper bound)
+
+# Plain-text placeholder format (human-readable for auditing / LIFO restoration)
+TEXT_PLACEHOLDER_FMT = "{kind}_{idx:04d}"   # wrapped in PUA sentinels on both sides
+
+# --------------------------------------------------------------------------- #
+# Logging
+# --------------------------------------------------------------------------- #
+import logging
+
+logging.basicConfig(
+    level=os.environ.get("REPAIR_LOG_LEVEL", "INFO"),
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+
+
+def get_logger(name: str) -> logging.Logger:
+    return logging.getLogger(name)

repair_pipeline_package/document.py

@@ -0,0 +1,127 @@
+"""
+Document object: the single atomic unit threading the whole pipeline.
+
+It carries:
+  - the current (possibly masked) text
+  - structured segments (code/math/structured) sliced out by masking, kept in
+    LIFO order
+  - an audit record for every change (stage number, operation, target segment,
+    pre/post SHA-256)
+  - rollbackable snapshots (pre-stage text snapshots that allow whole-stage undo)
+
+Design principles (paper Section 3.6): integrity, rollbackability,
+traceability, byte-level fidelity.
+"""
+
+from __future__ import annotations
+
+import enum
+import hashlib
+import time
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+def sha256_text(text: str) -> str:
+    """Compute SHA-256 over the UTF-8 encoding of the text (used for integrity checks and auditing)."""
+    return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+
+class SegmentType(enum.Enum):
+    PROSE = "PROSE"
+    CODE = "CODE"
+    MATH = "MATH"
+    STRUCTURED = "STRUCTURED"   # tables / JSON / YAML / TOML / XML / CSV / Markdown
+
+
+@dataclass
+class Segment:
+    """A non-prose segment sliced out by masking."""
+    seg_type: SegmentType
+    placeholder: str            # placeholder that replaces it in the text (includes PUA sentinels)
+    original_content: str       # original content (used for LIFO restore / SHA check)
+    content_sha256: str         # hash of content at the moment of masking
+    repaired_content: Optional[str] = None   # type-specific-repaired content
+    repaired_validated: bool = False         # whether pre-restore type-specific validation passed
+    nesting_depth: int = 0      # inner-to-outer extraction depth (basis for LIFO restore)
+    meta: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def make(cls, seg_type: SegmentType, placeholder: str, content: str,
+             nesting_depth: int = 0, **meta) -> "Segment":
+        return cls(
+            seg_type=seg_type,
+            placeholder=placeholder,
+            original_content=content,
+            content_sha256=sha256_text(content),
+            nesting_depth=nesting_depth,
+            meta=meta,
+        )
+
+
+@dataclass
+class AuditRecord:
+    """A single-change audit record (paper Section 3.6, fourth principle)."""
+    stage: int
+    operation: str
+    target: str                 # target object ("document" / segment placeholder, etc.)
+    sha_before: str
+    sha_after: str
+    note: str = ""
+    ts: float = field(default_factory=time.time)
+
+
+@dataclass
+class Document:
+    # --- raw + current state ---
+    raw_bytes: bytes = b""
+    original_text: str = ""     # text after Stage 1 decoding (basis for rollback)
+    text: str = ""              # current (possibly masked) text
+
+    # --- upstream metadata (used by the Stage 1 priority cascade) ---
+    http_charset: Optional[str] = None        # HTTP Content-Type declaration
+    html_meta_charset: Optional[str] = None   # <meta charset>
+    has_dom: bool = False                      # upstream retains an HTML DOM
+    dom_html: Optional[str] = None             # raw HTML (used by the DOM-priority path)
+    source_hint: Optional[str] = None          # e.g. "ocr" / "rfc" / "email"
+
+    # --- masked segments (LIFO) ---
+    segments: List[Segment] = field(default_factory=list)
+
+    # --- quality + state ---
+    detected_encoding: Optional[str] = None
+    quality_passed: Optional[bool] = None
+    quality_score: Optional[float] = None
+    discarded: bool = False
+    discard_reason: str = ""
+
+    # --- audit + rollback ---
+    audit: List[AuditRecord] = field(default_factory=list)
+    _snapshots: Dict[int, str] = field(default_factory=dict)   # stage -> text snapshot
+    meta: Dict[str, Any] = field(default_factory=dict)
+
+    # ---------------------------------------------------------------- #
+    def snapshot(self, stage: int) -> None:
+        """Save a text snapshot before a stage starts, enabling whole-stage rollback."""
+        self._snapshots[stage] = self.text
+
+    def rollback(self, stage: int) -> None:
+        if stage in self._snapshots:
+            self.text = self._snapshots[stage]
+
+    def record(self, stage: int, operation: str, sha_before: str,
+               target: str = "document", note: str = "") -> None:
+        self.audit.append(AuditRecord(
+            stage=stage, operation=operation, target=target,
+            sha_before=sha_before, sha_after=sha256_text(self.text), note=note,
+        ))
+
+    def apply(self, stage: int, operation: str, new_text: str,
+              target: str = "document", note: str = "") -> None:
+        """Apply a text-level change and auto-record it."""
+        sha_before = sha256_text(self.text)
+        self.text = new_text
+        self.record(stage, operation, sha_before, target, note)
+
+    def next_segment_index(self) -> int:
+        return len(self.segments)

repair_pipeline_package/masking/__init__.py

@@ -0,0 +1,5 @@
+from .dom_path import mask_dom
+from .text_path import mask_text
+from .sentinel import SentinelAllocator, lifo_order
+
+__all__ = ["mask_dom", "mask_text", "SentinelAllocator", "lifo_order"]

repair_pipeline_package/masking/dom_path.py

@@ -0,0 +1,259 @@
+"""
+DOM-priority path (Path A): three-level cascade hierarchical router.
+
+Level 1: <head> metadata pre-scan + MathJax/KaTeX delimiter configuration probing
+Level 2: 13-priority chain, single-pass DFS classification (outer first; strong
+         boundaries stop descent + subtree-scan exemption)
+Level 3: 42-dim XGBoost residual classifier for ambiguous containers like
+         <div>/<span>
+
+Extraction is "inner-to-outer"; segments are replaced with PUA sentinel
+placeholders.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import List, Optional, Tuple
+
+from ..config import XGB_AMBIGUOUS_BLOCK_MODEL, get_logger
+from ..document import Document, SegmentType
+from .sentinel import SentinelAllocator
+
+log = get_logger(__name__)
+
+# Level-2 priority-chain key signals (Table 4.2)
+_CODE_CLASS_RE = re.compile(
+    r"(?:^|\s)(language-|lang-|highlight|codehilite|sourceCode|prettyprint|"
+    r"brush:|hljs|chroma|rouge)", re.I)
+_MATH_CLASS_RE = re.compile(r"(?:^MathJax|^mjx-|^katex|mwe-math)", re.I)
+_LEGACY_CODE_TAGS = {"xmp", "listing", "plaintext", "tt"}
+_DEPRECATED_HINT = ("pre", "code", "math", "table", "ol", "ul", "dl")
+
+# Strong-boundary tag set: stop descent by default once matched (structural
+# container blocks get a subtree-scan exemption)
+_STRONG_BOUNDARY = {"pre", "code", "math", "table", "ol", "ul", "dl",
+                    "form", "figure", "figcaption", "blockquote",
+                    "script", "style", "xmp", "listing", "plaintext"}
+_STRUCT_CONTAINERS = {"table", "ol", "ul", "dl"}
+_AMBIGUOUS = {"div", "span"}
+
+
+class DomMetadata:
+    """Level-1 pre-scan result."""
+    def __init__(self):
+        self.inline_math_dollar = False     # enable $...$ inline math?
+        self.display_math = True            # $$ / \[ \] generally enabled by default
+        self.json_ld = []
+        self.libs = set()                   # mathjax / katex
+
+
+def _level1_prescan(soup) -> DomMetadata:
+    md = DomMetadata()
+    head = soup.find("head")
+    scope = head if head is not None else soup
+    # JSON-LD / Microdata
+    for s in scope.find_all("script", attrs={"type": "application/ld+json"}):
+        md.json_ld.append(s.get_text())
+    # MathJax / KaTeX loading + delimiter configuration
+    page_text = str(scope)
+    if re.search(r"mathjax", page_text, re.I):
+        md.libs.add("mathjax")
+    if re.search(r"katex", page_text, re.I):
+        md.libs.add("katex")
+    # Only activate inline $-math if explicit ['$','$'] config exists,
+    # to avoid swallowing currency-style text.
+    if re.search(r"inlineMath\s*[:=].*\[\s*\[\s*['\"]\$['\"]", page_text):
+        md.inline_math_dollar = True
+    return md
+
+
+def _classify_node_level2(node, md: DomMetadata) -> Optional[SegmentType]:
+    """Single-pass DFS priority chain (the 6 core rules of Table 4.2). Return None to continue descent."""
+    name = (node.name or "").lower()
+    classes = " ".join(node.get("class", [])) if hasattr(node, "get") else ""
+
+    # 1: JSON-LD / Microdata container
+    if name == "script" and node.get("type") == "application/ld+json":
+        return SegmentType.STRUCTURED
+    if node.get("itemscope") is not None:
+        return SegmentType.STRUCTURED
+    # 2: math
+    if name == "math" or _MATH_CLASS_RE.search(classes):
+        return SegmentType.MATH
+    if name == "img" and node.get("alt") and re.search(r"[=+\\^]", node.get("alt", "")):
+        return SegmentType.MATH
+    # 3: <pre><code> / code class names / legacy HTML code tags
+    if name == "pre" or _CODE_CLASS_RE.search(classes) or name in _LEGACY_CODE_TAGS:
+        return SegmentType.CODE
+    if name == "code" and (node.parent is None or node.parent.name != "pre"):
+        return SegmentType.CODE
+    # 4: inline code-semantic tags under a non-<pre> parent
+    if name in {"kbd", "samp", "var"}:
+        return SegmentType.CODE
+    # 5: data tables (layout tables get an exemption; descend into each cell)
+    if name == "table":
+        return SegmentType.STRUCTURED if _is_data_table(node) else None
+    # 6: lists (subtree-scan first; classify the whole as structured data)
+    if name in {"ul", "ol", "dl"}:
+        return SegmentType.STRUCTURED
+    return None
+
+
+def _is_data_table(table) -> bool:
+    """Lightweight layout-vs-data-table decision (simplified version of the paper's Table 4.3 6-layer heuristic)."""
+    if table.find("th") is not None or table.find("thead") is not None:
+        return True
+    rows = table.find_all("tr")
+    if len(rows) < 2:
+        return False
+    col_counts = [len(r.find_all(["td", "th"])) for r in rows]
+    if not col_counts:
+        return False
+    # Consistent column count >= 2 and no nested layout elements -> favours data table
+    consistent = len(set(col_counts)) == 1 and col_counts[0] >= 2
+    has_layout = table.find(["nav", "form"]) is not None
+    return consistent and not has_layout
+
+
+# --------------------------------------------------------------------------- #
+# Level-3 residual classifier
+# --------------------------------------------------------------------------- #
+class _XGBResidualClassifier:
+    """42-dim feature-driven XGBoost residual classifier (ambiguous div/span containers)."""
+
+    def __init__(self, model_path: str):
+        self.model = None
+        try:
+            import xgboost as xgb  # noqa
+            self.model = xgb.Booster()
+            self.model.load_model(model_path)
+            log.info("Loaded XGBoost residual classifier: %s", model_path)
+        except Exception as e:  # model missing -> fall back to pure heuristics
+            log.warning("XGBoost residual classifier unavailable (%s); "
+                        "falling back to heuristics.", e)
+
+    def _features(self, node) -> List[float]:
+        """Build a 42-dim feature vector (nine signal groups, simplified but dimension-aligned)."""
+        text = node.get_text() or ""
+        name = (node.name or "").lower()
+        classes = " ".join(node.get("class", []))
+        n = max(len(text), 1)
+        alpha = sum(c.isalpha() for c in text) / n
+        digit = sum(c.isdigit() for c in text) / n
+        space = sum(c.isspace() for c in text) / n
+        symbol = 1.0 - alpha - digit - space
+        feats = [
+            # DOM structure (8)
+            1.0 if name == "div" else 0.0, 1.0 if name == "span" else 0.0,
+            float(len(list(node.parents))), float(len(node.find_all(recursive=False))),
+            float(len(node.find_next_siblings())), float(len(node.find_previous_siblings())),
+            1.0 if node.get("class") else 0.0, float(len(name)),
+            # Inline style (2)
+            1.0 if re.search(r"monospace|courier", str(node.get("style", "")), re.I) else 0.0,
+            1.0 if re.search(r"center", str(node.get("style", "")), re.I) else 0.0,
+            # Content patterns (4)
+            1.0 if re.search(r"\$|\\frac|\\sum|\\[\[\]]", text) else 0.0,
+            1.0 if re.search(r"\b(def|import|class|function|var|public)\b", text) else 0.0,
+            1.0 if re.search(r"^\s*[\{\[]", text) else 0.0,
+            1.0 if re.search(r"[\{\}\[\]]", text) else 0.0,
+            # Character-class ratios (4)
+            alpha, digit, max(symbol, 0.0), space,
+            # Code statistics (4)
+            len(re.findall(r"\b(def|class|import|return|for|while)\b", text)) / n,
+            float(text.count("(") - text.count(")")),
+            (text.count(";")) / max(text.count("\n") + 1, 1),
+            0.0,  # indentation consistency (placeholder)
+            # Math statistics (3)
+            len(re.findall(r"[\u2211\u222b\u221a\u03c0\u00b1\u00d7\u00f7\u2264\u2265\u2260\u221e]", text)) / n,
+            float(len(re.findall(r"\$|\\\[|\\\]", text))),
+            float(len(re.findall(r"[\u03b1\u03b2\u03b3\u03b4\u03b8\u03bb\u03bc\u03c3\u03c6\u03c8\u03c9]", text))),
+            # Tables (4)
+            1.0 if node.find("th") else 0.0, 1.0 if node.find("thead") else 0.0,
+            float(len(node.find_all("tr"))), float(len(node.find_all("td"))),
+            # Other block-level (3)
+            len(node.find_all("a")) / max(len(text.split()), 1),
+            float(max((len(w) for w in text.split()), default=0)),
+            len(re.findall(r"(.)\1{3,}", text)) / n,
+        ]
+        # Context window (10) -- pad with zeros to reach 42 dims
+        feats += [0.0] * (42 - len(feats))
+        return feats[:42]
+
+    def classify(self, node) -> Optional[SegmentType]:
+        if self.model is None:
+            return self._heuristic(node)
+        try:
+            import xgboost as xgb
+            dm = xgb.DMatrix([self._features(node)])
+            pred = int(self.model.predict(dm)[0])
+            return [None, SegmentType.CODE, SegmentType.MATH,
+                    SegmentType.STRUCTURED][pred]
+        except Exception:
+            return self._heuristic(node)
+
+    @staticmethod
+    def _heuristic(node) -> Optional[SegmentType]:
+        text = node.get_text() or ""
+        if re.search(r"\$\$|\\begin\{|\\frac|\\sum", text):
+            return SegmentType.MATH
+        if re.search(r"\b(def|import|class|function)\b.*[\(\):{]", text):
+            return SegmentType.CODE
+        if re.search(r"^\s*[\{\[].*[\}\]]\s*$", text, re.S):
+            return SegmentType.STRUCTURED
+        return None
+
+
+# --------------------------------------------------------------------------- #
+def mask_dom(doc: Document) -> None:
+    """Execute the three-level cascade classification and inner-to-outer masking on the HTML DOM."""
+    try:
+        from bs4 import BeautifulSoup
+    except Exception as e:
+        log.warning("bs4 unavailable (%s); skipping DOM masking.", e)
+        return
+
+    soup = BeautifulSoup(doc.dom_html or doc.text, "lxml")
+    md = _level1_prescan(soup)
+    residual = _XGBResidualClassifier(XGB_AMBIGUOUS_BLOCK_MODEL)
+    alloc = SentinelAllocator(doc)
+
+    # Collect candidates by descending DOM depth -> inner-to-outer extraction.
+    all_nodes = list(soup.find_all(True))
+    all_nodes.sort(key=lambda n: len(list(n.parents)), reverse=True)
+
+    for node in all_nodes:
+        if node.decomposed or node.parent is None:
+            continue
+        name = (node.name or "").lower()
+        seg_type = _classify_node_level2(node, md)
+        if seg_type is None and name in _AMBIGUOUS:
+            seg_type = residual.classify(node)
+        if seg_type is None:
+            continue
+
+        # Strong-boundary tags: run a subtree scan before sealing. If they
+        # contain inner targets, do not stop descent here.
+        if name in _STRONG_BOUNDARY and name not in _STRUCT_CONTAINERS:
+            if _has_inner_target(node):
+                continue  # let deeper nodes be masked first (inner-to-outer)
+
+        depth = len(list(node.parents))
+        placeholder = alloc.mask(seg_type, str(node), nesting_depth=depth,
+                                 tag=name)
+        node.replace_with(placeholder)
+
+    doc.text = soup.get_text() if soup.body is None else str(soup)
+    # DOM path uses the rendered text body directly.
+    doc.text = soup.get_text()
+
+
+def _has_inner_target(node) -> bool:
+    for child in node.find_all(True, recursive=True):
+        cn = (child.name or "").lower()
+        if cn in {"math", "table", "ul", "ol", "dl"} or cn in _LEGACY_CODE_TAGS:
+            return True
+        classes = " ".join(child.get("class", []))
+        if _CODE_CLASS_RE.search(classes) or _MATH_CLASS_RE.search(classes):
+            return True
+    return False

repair_pipeline_package/masking/sentinel.py

@@ -0,0 +1,49 @@
+"""
+PUA sentinel character allocation and LIFO segment storage.
+
+The masking stage replaces code/math/structured segments with placeholders;
+each placeholder is wrapped in PUA sentinel characters on both sides. Each
+segment computes its SHA-256 at the moment of masking, and segments are
+pushed onto a stack in "inner-to-outer" extraction order. Stage 10 restores
+in LIFO (last-in-first-out) order, guaranteeing byte-level losslessness
+across nested mixed-content structures.
+"""
+
+from __future__ import annotations
+
+from typing import List
+
+from ..config import TEXT_PLACEHOLDER_FMT
+from ..document import Document, Segment, SegmentType
+
+
+class SentinelAllocator:
+    """Allocates unique, human-readable PUA-wrapped placeholders for a single document."""
+
+    def __init__(self, doc: Document):
+        self.doc = doc
+        self._counters = {st: 0 for st in SegmentType}
+
+    def mask(self, seg_type: SegmentType, content: str,
+             nesting_depth: int = 0, **meta) -> str:
+        """Register a segment and return its placeholder string."""
+        idx = self.doc.next_segment_index()
+        kind = seg_type.value
+        placeholder = TEXT_PLACEHOLDER_FMT.format(kind=kind, idx=idx)
+        seg = Segment.make(seg_type, placeholder, content,
+                           nesting_depth=nesting_depth, **meta)
+        self.doc.segments.append(seg)
+        self._counters[seg_type] += 1
+        return placeholder
+
+
+def lifo_order(segments: List[Segment]) -> List[Segment]:
+    """
+    Return segments in LIFO restoration order: last-in-first-out.
+
+    Inner-to-outer extraction means inner segments (higher nesting_depth) are
+    masked first and pushed first; restoration must pop them last-in-first-out
+    so the innermost segments are restored first, naturally completing the
+    nested back-fill.
+    """
+    return list(reversed(segments))

repair_pipeline_package/masking/text_path.py

@@ -0,0 +1,153 @@
+"""
+Plain-text fallback path (Path B): four-step extraction flow.
+
+Step 1 - Boundary Forcing: inject blank lines around known structural separators
+Step 2 - Inline Extraction with Masking: inner-to-outer, physically extract
+         strongly-delimited inline content by priority
+Step 3 - Empty-line Block Segmentation
+Step 4 - Block-level Classification: heuristic + lightweight ML, two layers
+
+Output is isomorphic to the DOM path (each block has a type label); code,
+math, and structured segments are replaced with PUA placeholders.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import List, Tuple
+
+from ..config import TEXT_BLOCK_ML_MODEL, get_logger
+from ..document import Document, SegmentType
+from .sentinel import SentinelAllocator
+
+log = get_logger(__name__)
+
+# Boundary forcing: inject blank lines around these structural separators.
+_BOUNDARY_PATTERNS = [
+    r"(```)",                       # fenced code marker
+    r"(</?(?:pre|code)[^>]*>)",     # remaining <pre>/<code>
+    r"(\$\$)", r"(\\\[)", r"(\\\])",  # display math
+    r"(\\begin\{[^}]+\})", r"(\\end\{[^}]+\})",  # LaTeX environments
+    r"(^#{1,6}\s)",                # Markdown headings
+    r"(^[-*_]{3,}\s*$)",           # horizontal rule
+    r"(^\s*\|.*\|\s*$)",        # structured-data rows (tables)
+    r"(^>>>|^In\[)",               # REPL prompts
+]
+
+
+def _boundary_forcing(text: str) -> str:
+    out = text
+    for pat in _BOUNDARY_PATTERNS:
+        out = re.sub(pat, r"\n\n\1\n\n", out, flags=re.M)
+    # Fold redundant newlines for idempotence.
+    out = re.sub(r"\n{3,}", "\n\n", out)
+    return out
+
+
+# Step 2: inline-extraction priority (inner-to-outer: fenced/display first, then inline).
+_INLINE_RULES: List[Tuple[SegmentType, re.Pattern]] = [
+    (SegmentType.CODE, re.compile(r"```.*?```", re.S)),                 # fenced code
+    (SegmentType.MATH, re.compile(r"\$\$.*?\$\$", re.S)),           # display math
+    (SegmentType.MATH, re.compile(r"\\\[.*?\\\]", re.S)),
+    (SegmentType.CODE, re.compile(r"<pre[^>]*>.*?</pre>", re.S | re.I)),
+    (SegmentType.CODE, re.compile(r"<code[^>]*>.*?</code>", re.S | re.I)),
+    (SegmentType.MATH, re.compile(r"\\\(.*?\\\)", re.S)),         # inline math
+    (SegmentType.CODE, re.compile(r"`[^`\n]+`")),                      # inline code
+]
+
+
+def _inline_extract(text: str, alloc: SentinelAllocator) -> str:
+    out = text
+    depth = 100  # inline content gets higher nesting_depth so LIFO restores it first
+    for seg_type, pat in _INLINE_RULES:
+        def _sub(m, _st=seg_type):
+            ph = alloc.mask(_st, m.group(0), nesting_depth=depth)
+            return ph
+        out = pat.sub(_sub, out)
+        depth -= 1
+    return out
+
+
+_EMPTY_LINE_SPLIT = re.compile(r"\n[\t\u00a0]*\n+")
+
+
+def _segment_blocks(text: str) -> List[str]:
+    return [b for b in _EMPTY_LINE_SPLIT.split(text) if b.strip()]
+
+
+# Step 4: block-level classification features
+_CODE_KW = re.compile(r"\b(def|class|import|return|for|while|function|var|"
+                      r"public|private|#include|println|System\.)\b")
+_LATEX = re.compile(r"\\frac|\\sum|\\int|\$.+?\$|\\begin|\\alpha|\\beta")
+_ARTICLES = re.compile(r"\b(a|an|the|and|but|or|is|are|was|were)\b", re.I)
+
+
+class _BlockClassifier:
+    """Two-layer heuristic + lightweight ML block-level classifier."""
+
+    def __init__(self, model_path: str):
+        self.model = None
+        try:
+            import lightgbm as lgb  # noqa
+            self.model = lgb.Booster(model_file=model_path)
+            log.info("Loaded text block LGBM classifier: %s", model_path)
+        except Exception as e:
+            log.warning("Text block ML classifier unavailable (%s); "
+                        "heuristic-only.", e)
+
+    @staticmethod
+    def _line_feats(block: str):
+        lines = block.splitlines() or [block]
+        n = max(len(lines), 1)
+        latex_density = sum(bool(_LATEX.search(l)) for l in lines) / n
+        code_density = sum(bool(_CODE_KW.search(l)) for l in lines) / n
+        prose_density = sum(bool(_ARTICLES.search(l)) for l in lines) / n
+        special = sum(c in "\\${}|" for c in block) / max(len(block), 1)
+        return latex_density, code_density, prose_density, special
+
+    def classify(self, block: str) -> SegmentType:
+        latex_d, code_d, prose_d, special = self._line_feats(block)
+        # Layer 1: strong heuristic match (paper-specified thresholds)
+        if latex_d > 0.30:
+            return SegmentType.MATH
+        if code_d > 0.25:
+            return SegmentType.CODE
+        if prose_d > 0.60 and special < 0.05:
+            return SegmentType.PROSE
+        if re.match(r"^\s*\|.*\|", block) or re.match(r"^\s*[\{\[]", block):
+            return SegmentType.STRUCTURED
+        # Layer 2: lightweight ML handles ambiguous blocks
+        if self.model is not None:
+            try:
+                pred = int(round(float(self.model.predict([[latex_d, code_d,
+                                                             prose_d, special]])[0])))
+                return [SegmentType.PROSE, SegmentType.CODE, SegmentType.MATH,
+                        SegmentType.STRUCTURED][min(max(pred, 0), 3)]
+            except Exception:
+                pass
+        return SegmentType.PROSE
+
+
+def mask_text(doc: Document) -> None:
+    """Main entry for the plain-text path."""
+    alloc = SentinelAllocator(doc)
+    text = _boundary_forcing(doc.text)
+    text = _inline_extract(text, alloc)        # strongly-delimited inline content already masked
+
+    blocks = _segment_blocks(text)
+    clf = _BlockClassifier(TEXT_BLOCK_ML_MODEL)
+
+    rebuilt: List[str] = []
+    for blk in blocks:
+        # Skip blocks containing only placeholders (already handled during inline extraction)
+        bt = clf.classify(blk)
+        if bt in (SegmentType.CODE, SegmentType.MATH, SegmentType.STRUCTURED):
+            ph = alloc.mask(bt, blk, nesting_depth=0)
+            rebuilt.append(ph)
+        else:
+            rebuilt.append(blk)
+
+    sha_before = doc.text
+    doc.apply(stage=2, operation="mask_text_path",
+              new_text="\n\n".join(rebuilt),
+              note=f"masked {len(doc.segments)} segments (text path)")

repair_pipeline_package/pipeline.py

@@ -0,0 +1,104 @@
+"""
+Pipeline orchestrator.
+
+Execution order = the paper's ten-stage order + a single mandatory modification:
+move "mixed-content masking" (Stage 3) before "ftfy atomic repair" (Stage 2).
+
+Paper canonical order:  1 encoding -> 2 ftfy -> 3 masking -> 4 artifacts ->
+                        5 line-level -> 6 character -> 7 whitespace ->
+                        8 OCR -> 9 quality -> 10 restore
+This pipeline's order:  1 encoding -> 3 masking -> 2 ftfy -> 4 artifacts ->
+                        5 line-level -> 6 character -> 7 whitespace -> 8 OCR ->
+                        [type-specific repair + pre-restore validation] ->
+                        9 quality -> 10 restore
+
+Type-specific repair (repair of code/math/structured segments + pre-restore
+type-specific validation) runs after all text-level repairs are complete on
+the masked text and before quality validation, on each segment
+independently, ahead of the Stage 10 LIFO restore.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .config import get_logger
+from .document import Document
+from .stages import (stage01_encoding, stage02_masking, stage03_ftfy,
+                     stage04_artifacts, stage05_linelevel, stage06_charnorm,
+                     stage07_whitespace, stage08_ocr, stage09_quality,
+                     stage10_restore)
+from .typed_repair import repair_and_validate_segments
+
+log = get_logger(__name__)
+
+
+class RepairPipeline:
+    """Ten-stage corpus data repair pipeline (masking-first variant)."""
+
+    # (execution index, paper-stage number, name, function) — used for log/audit display
+    EXECUTION_PLAN = [
+        ("1", 1, "Dual-encoding detection and repair", stage01_encoding.run),
+        ("2", 2, "Mixed-content masking [moved forward]", stage02_masking.run),     # moved earlier
+        ("3", 3, "ftfy atomic repair", stage03_ftfy.run),                            # moved later
+        ("4", 4, "Structural artifact removal", stage04_artifacts.run),
+        ("5", 5, "Line-level repair", stage05_linelevel.run),
+        ("6", 6, "Character-level normalization", stage06_charnorm.run),
+        ("7", 7, "Whitespace normalization", stage07_whitespace.run),
+        ("8", 8, "OCR detection and correction", stage08_ocr.run),
+        # -- type-specific repair + pre-restore validation (on masked segments) --
+        ("9", 9, "Masked-text quality validation", stage09_quality.run),
+        ("10", 10, "LIFO restore and integrity check", stage10_restore.run),
+    ]
+
+    def run(self,
+            data,
+            *,
+            http_charset: Optional[str] = None,
+            html_meta_charset: Optional[str] = None,
+            has_dom: bool = False,
+            dom_html: Optional[str] = None,
+            source_hint: Optional[str] = None) -> Document:
+        """
+        Process a single document.
+
+        data: bytes (raw byte stream, decoded by Stage 1) or str (pre-decoded text).
+        """
+        doc = Document(
+            http_charset=http_charset,
+            html_meta_charset=html_meta_charset,
+            has_dom=has_dom or bool(dom_html),
+            dom_html=dom_html,
+            source_hint=source_hint,
+        )
+        if isinstance(data, bytes):
+            doc.raw_bytes = data
+        else:
+            doc.text = data
+            doc.original_text = data
+
+        for exec_no, paper_stage, name, fn in self.EXECUTION_PLAN:
+            doc.snapshot(paper_stage)
+            log.info("[exec %s / paper-stage %d] %s", exec_no, paper_stage, name)
+            try:
+                fn(doc)
+            except Exception as e:
+                log.exception("stage %s (%s) failed: %s", exec_no, name, e)
+                # A single stage failure must not abort the whole pipeline:
+                # roll back this stage and continue with the next.
+                doc.rollback(paper_stage)
+
+            # After OCR (execution index 8) and before quality validation,
+            # run type-specific repair + pre-restore validation.
+            if exec_no == "8" and not doc.discarded:
+                log.info("[typed-repair] type-specific segment repair + pre-restore validation")
+                try:
+                    repair_and_validate_segments(doc)
+                except Exception as e:
+                    log.exception("typed repair failed: %s", e)
+
+        return doc
+
+    def run_text(self, text: str, **kwargs) -> str:
+        """Convenience interface: input text, return final repaired text."""
+        return self.run(text, **kwargs).text

repair_pipeline_package/quality/__init__.py

@@ -0,0 +1,3 @@
+from .ensemble import QualityEnsemble
+
+__all__ = ["QualityEnsemble"]

repair_pipeline_package/quality/ensemble.py

@@ -0,0 +1,186 @@
+"""
+Six-tool complementary quality-scoring ensemble (paper Section 6.2 / Table 8.8 / Table 8.9).
+
+Final selection (with GPU-required tools removed; composite score 0.896):
+    DCLM_FastText + LanguageTool + NeMo-DataTrove-DataJuicer joint-metric
+    system + ftfy + NLTK + unicodedata.
+
+Aggregation strategy: each structural anomaly is scored exclusively by its
+single best-performing tool (max-aggregation; tools cooperate, do not
+compete), rather than a weighted average. The document is emitted with a
+binary pass/reject signal.
+
+Fully CPU; operates on the masked text (code/math/structured segments remain
+PUA placeholders).
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import Dict
+
+from ..config import (DCLM_FASTTEXT_MODEL, QUALITY_PASS_THRESHOLD, get_logger)
+
+log = get_logger(__name__)
+
+
+# --------------------------------------------------------------------------- #
+# Per-tool: return a [0,1] "cleanness" score (higher = cleaner)
+# --------------------------------------------------------------------------- #
+class _DclmFastText:
+    """DCLM_FastText: curly quotes, PDF-extraction artifacts, boilerplate, nav-bar templates."""
+    def __init__(self):
+        self.model = None
+        try:
+            import fasttext
+            self.model = fasttext.load_model(DCLM_FASTTEXT_MODEL)
+            log.info("Loaded DCLM fastText: %s", DCLM_FASTTEXT_MODEL)
+        except Exception as e:
+            log.warning("DCLM fastText unavailable (%s); heuristic fallback.", e)
+
+    def score(self, text: str) -> float:
+        if self.model is not None:
+            try:
+                labels, probs = self.model.predict(text.replace("\n", " ")[:4000])
+                p = float(probs[0])
+                return p if "__label__hq" in labels[0] or "__label__1" in labels[0] \
+                    else 1.0 - p
+            except Exception:
+                pass
+        # Fallback heuristic: curly-quote / nav-separator density
+        curly = len(re.findall(r"[\u2018\u2019\u201c\u201d]", text))
+        nav = len(re.findall(r"\s\|\s|\u00bb|\u203a", text))
+        n = max(len(text), 1)
+        return max(0.0, 1.0 - (curly + nav) / n * 20)
+
+
+class _LanguageTool:
+    """LanguageTool: full-width characters, basic control characters, residual HTML."""
+    def __init__(self):
+        self.tool = None
+        try:
+            import language_tool_python
+            self.tool = language_tool_python.LanguageTool("en-US")
+        except Exception as e:
+            log.warning("LanguageTool unavailable (%s); heuristic fallback.", e)
+
+    def score(self, text: str) -> float:
+        fullwidth = len(re.findall(r"[\uff01-\uff5e\u3000]", text))
+        html_resid = len(re.findall(r"</?[a-z][a-z0-9]*\b[^>]*>|&[a-z]+;", text, re.I))
+        ctrl = len(re.findall(r"[\x00-\x08\x0b\x0c\x0e-\x1f]", text))
+        n = max(len(text), 1)
+        return max(0.0, 1.0 - (fullwidth + html_resid * 3 + ctrl * 5) / n * 15)
+
+
+class _NemoDataTroveDataJuicer:
+    """NeMo-DataTrove-DataJuicer joint-metric system (rule/statistic-based; the strongest general-purpose component).
+    Targets: mojibake, hyphenated wraps, intra-word newlines, chaotic
+    tabs/spaces, inconsistent UTF-8 mojibake, residual encoding artifacts,
+    zero-width characters, soft hyphens."""
+    def score(self, text: str) -> float:
+        n = max(len(text), 1)
+        replacement = text.count("\uFFFD")
+        zerowidth = len(re.findall(r"[\u200b-\u200d\u2060\ufeff]", text))
+        soft_hyphen = text.count("\u00ad")
+        mojibake = len(re.findall(r"\u00c3.|\u00e2\u20ac.|\u00c2.", text))   # typical multi-pass mojibake patterns
+        tabspace = len(re.findall(r"\t \t| \t ", text))
+        mid_word_break = len(re.findall(r"[A-Za-z]\n[a-z]", text))  # intra-word newline
+        bad = (replacement * 4 + zerowidth * 3 + soft_hyphen * 2
+               + mojibake * 3 + tabspace + mid_word_break)
+        return max(0.0, 1.0 - bad / n * 12)
+
+
+class _Nltk:
+    """NLTK: multi-pass encoding errors, replacement-character mojibake, undecomposed
+    ligatures, mixed line endings, NFD residue, private-use-area characters, form-feed."""
+    def __init__(self):
+        self.ok = False
+        try:
+            import nltk  # noqa
+            from nltk.tokenize import word_tokenize  # noqa
+            self.ok = True
+        except Exception as e:
+            log.warning("NLTK unavailable (%s); heuristic fallback.", e)
+
+    def score(self, text: str) -> float:
+        n = max(len(text), 1)
+        ligatures = len(re.findall(r"[\ufb00-\ufb06]", text))   # ff fi fl ffi ffl etc.
+        mixed_eol = 1 if ("\r\n" in text and "\n" in text.replace("\r\n", "")) else 0
+        nfd = 0
+        try:
+            nfd = sum(1 for c in text if unicodedata.combining(c))
+        except Exception:
+            pass
+        pua = len(re.findall(r"[\ue000-\uefff]", text))   # native PUA (sentinel block is at F000+, excluded)
+        formfeed = text.count("\x0c")
+        bad = ligatures * 2 + mixed_eol * 5 + nfd + pua * 2 + formfeed * 3
+        return max(0.0, 1.0 - bad / n * 10)
+
+
+class _UnicodeData:
+    """unicodedata: C1 control characters, isolated surrogates, residual control characters, BOM."""
+    def score(self, text: str) -> float:
+        n = max(len(text), 1)
+        c1 = len(re.findall(r"[\u0080-\u009f]", text))
+        bom = text.count("\ufeff")
+        surrogate = len(re.findall(r"[\ud800-\udfff]", text))
+        ctrl = sum(1 for c in text if unicodedata.category(c) == "Cc"
+                   and c not in "\t\n\r")
+        bad = c1 * 4 + bom * 2 + surrogate * 5 + ctrl * 3
+        return max(0.0, 1.0 - bad / n * 12)
+
+
+class _Ftfy:
+    """ftfy reverse-wrapped as a detector: inter-word spurious newlines, 0xA0 -> space, BBCode tags.
+    Uses the edit-distance between pre- and post-repair text as a quality
+    signal (larger distance = dirtier)."""
+    def score(self, text: str) -> float:
+        try:
+            import ftfy
+            fixed = ftfy.fix_text(text)
+        except Exception:
+            return 1.0
+        # Levenshtein approximation: use character-difference ratio
+        if not text:
+            return 1.0
+        diff = sum(1 for a, b in zip(text, fixed) if a != b) + abs(len(text) - len(fixed))
+        return max(0.0, 1.0 - diff / max(len(text), 1) * 4)
+
+
+# --------------------------------------------------------------------------- #
+# Ensemble: each structural anomaly class -> best tool (Table 8.9 assignment)
+# --------------------------------------------------------------------------- #
+class QualityEnsemble:
+    def __init__(self):
+        self.dclm = _DclmFastText()
+        self.lt = _LanguageTool()
+        self.nemo = _NemoDataTroveDataJuicer()
+        self.nltk = _Nltk()
+        self.uni = _UnicodeData()
+        self.ftfy = _Ftfy()
+
+    def evaluate(self, text: str) -> Dict[str, float]:
+        """Return per-tool subscores in their assigned categories plus the max-aggregation composite."""
+        scores = {
+            "nemo": self.nemo.score(text),
+            "nltk": self.nltk.score(text),
+            "unicodedata": self.uni.score(text),
+            "dclm_fasttext": self.dclm.score(text),
+            "ftfy": self.ftfy.score(text),
+            "languagetool": self.lt.score(text),
+        }
+        # Engineering approximation of "pick the best tool per anomaly":
+        # composite cleanness = geometric mean of per-tool subscores (any
+        # collapsed category drags the total down), which matches the
+        # "weakest link sets the floor" semantics better than a weighted average.
+        import math
+        vals = [max(v, 1e-3) for v in scores.values()]
+        composite = math.exp(sum(math.log(v) for v in vals) / len(vals))
+        scores["composite"] = composite
+        return scores
+
+    def verify(self, text: str) -> tuple[bool, float, Dict[str, float]]:
+        scores = self.evaluate(text)
+        composite = scores["composite"]
+        return composite >= QUALITY_PASS_THRESHOLD, composite, scores

repair_pipeline_package/run.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""
+Command-line entry point.
+
+Usage:
+  # Process a single file (Stage 1 auto-decodes the byte stream)
+  python -m repair_pipeline.run input.html -o out.jsonl
+
+  # Process every file under a directory
+  python -m repair_pipeline.run ./corpus_dir -o out.jsonl
+
+  # Mark the source as OCR / provide an HTTP charset
+  python -m repair_pipeline.run scan.txt --source-hint ocr --http-charset utf-8
+
+Output is JSONL, one document per line:
+  {path, encoding, quality_passed, quality_score, discarded, n_segments,
+   audit:[...], text}
+"""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import json
+import os
+import sys
+from pathlib import Path
+
+from .pipeline import RepairPipeline
+
+
+def _iter_inputs(path: Path):
+    if path.is_dir():
+        for p in sorted(path.rglob("*")):
+            if p.is_file():
+                yield p
+    else:
+        yield path
+
+
+def _doc_to_record(path: Path, doc) -> dict:
+    return {
+        "path": str(path),
+        "encoding": doc.detected_encoding,
+        "quality_passed": doc.quality_passed,
+        "quality_score": doc.quality_score,
+        "discarded": doc.discarded,
+        "discard_reason": doc.discard_reason,
+        "n_segments": len(doc.segments),
+        "audit": [dataclasses.asdict(a) for a in doc.audit],
+        "text": doc.text,
+    }
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(description="Ten-stage corpus data repair pipeline (masking-first variant)")
+    ap.add_argument("input", help="input file or directory")
+    ap.add_argument("-o", "--output", default="-", help="output JSONL path (defaults to stdout)")
+    ap.add_argument("--has-dom", action="store_true", help="input retains HTML DOM")
+    ap.add_argument("--http-charset", default=None)
+    ap.add_argument("--source-hint", default=None, help="e.g. ocr / rfc / email")
+    args = ap.parse_args(argv)
+
+    pipe = RepairPipeline()
+    out = sys.stdout if args.output == "-" else open(args.output, "w", encoding="utf-8")
+    try:
+        for p in _iter_inputs(Path(args.input)):
+            raw = p.read_bytes()
+            is_html = p.suffix.lower() in (".html", ".htm")
+            doc = pipe.run(
+                raw,
+                http_charset=args.http_charset,
+                has_dom=args.has_dom or is_html,
+                dom_html=raw.decode("utf-8", "replace") if (args.has_dom or is_html) else None,
+                source_hint=args.source_hint,
+            )
+            out.write(json.dumps(_doc_to_record(p, doc), ensure_ascii=False) + "\n")
+    finally:
+        if out is not sys.stdout:
+            out.close()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

repair_pipeline_package/stages/__init__.py

@@ -0,0 +1,13 @@
+"""Stage module collection. Filenames follow the paper's canonical stage numbering; execution order is set by the pipeline."""
+
+from . import (stage01_encoding, stage02_masking, stage03_ftfy,
+               stage04_artifacts, stage05_linelevel, stage06_charnorm,
+               stage07_whitespace, stage08_ocr, stage09_quality,
+               stage10_restore)
+
+__all__ = [
+    "stage01_encoding", "stage02_masking", "stage03_ftfy",
+    "stage04_artifacts", "stage05_linelevel", "stage06_charnorm",
+    "stage07_whitespace", "stage08_ocr", "stage09_quality",
+    "stage10_restore",
+]

repair_pipeline_package/stages/stage01_encoding.py

@@ -0,0 +1,137 @@
+"""
+Stage 1: dual-encoding detection and repair (paper Section 7.1).
+
+- Dual-detector voting fusion: chardet 7.x + charset-normalizer
+  (agreement -> adopt; disagreement -> charset-normalizer wins)
+- Five-level priority cascade: BOM -> HTTP Content-Type -> HTML <meta charset>
+  -> chardet statistical detection -> Windows-1252 fallback
+- English fast path: UTF-8 -> Windows-1252 cascaded decode (~100x speedup)
+
+Outputs clean Unicode text as the input to all later stages.
+NOTE: this stage is the bearer of the "encoding-first" constraint; it does
+NOT strip control characters or apply NFC.
+"""
+
+from __future__ import annotations
+
+import codecs
+import re
+from typing import Optional
+
+from ..config import get_logger
+from ..document import Document, sha256_text
+
+log = get_logger(__name__)
+
+STAGE = 1
+
+_BOM_TABLE = [
+    (codecs.BOM_UTF8, "utf-8-sig"),
+    (codecs.BOM_UTF32_LE, "utf-32"),
+    (codecs.BOM_UTF32_BE, "utf-32"),
+    (codecs.BOM_UTF16_LE, "utf-16"),
+    (codecs.BOM_UTF16_BE, "utf-16"),
+]
+
+_META_CHARSET_RE = re.compile(
+    rb"""<meta[^>]+charset\s*=\s*["']?\s*([a-zA-Z0-9_\-]+)""", re.I)
+
+
+def _detect_bom(raw: bytes) -> Optional[str]:
+    for bom, enc in _BOM_TABLE:
+        if raw.startswith(bom):
+            return enc
+    return None
+
+
+def _detect_meta_charset(raw: bytes) -> Optional[str]:
+    m = _META_CHARSET_RE.search(raw[:4096])
+    return m.group(1).decode("ascii", "ignore") if m else None
+
+
+def _vote_detectors(raw: bytes) -> Optional[str]:
+    """Voting fusion between chardet and charset-normalizer."""
+    chardet_enc = csn_enc = None
+    try:
+        import chardet
+        r = chardet.detect(raw)
+        chardet_enc = (r.get("encoding") or "").lower() or None
+    except Exception:
+        pass
+    try:
+        from charset_normalizer import from_bytes
+        best = from_bytes(raw).best()
+        csn_enc = best.encoding if best is not None else None
+    except Exception:
+        pass
+
+    if chardet_enc and csn_enc:
+        if chardet_enc == csn_enc:
+            return chardet_enc
+        return csn_enc          # disagreement -> charset-normalizer wins
+    return csn_enc or chardet_enc
+
+
+def _english_fast_path(raw: bytes) -> Optional[str]:
+    """UTF-8 -> Windows-1252 cascade: enabled when ASCII ratio > 95%."""
+    sample = raw[:65536]
+    if not sample:
+        return None
+    ascii_ratio = sum(b < 0x80 for b in sample) / len(sample)
+    if ascii_ratio < 0.95:
+        return None
+    try:
+        raw.decode("utf-8")
+        return "utf-8"
+    except UnicodeDecodeError:
+        return "cp1252"   # Windows-1252 never raises on arbitrary bytes
+
+
+def detect_encoding(doc: Document) -> str:
+    raw = doc.raw_bytes
+    # 1) BOM
+    enc = _detect_bom(raw)
+    if enc:
+        return enc
+    # 2) HTTP Content-Type charset
+    if doc.http_charset:
+        return doc.http_charset
+    # 3) HTML <meta charset>
+    meta = doc.html_meta_charset or _detect_meta_charset(raw)
+    if meta:
+        doc.html_meta_charset = meta
+        return meta
+    # English fast path (optional optimization in place of statistical detection)
+    fast = _english_fast_path(raw)
+    if fast:
+        return fast
+    # 4) statistical detection (dual-detector vote)
+    voted = _vote_detectors(raw)
+    if voted:
+        return voted
+    # 5) Windows-1252 fallback
+    return "cp1252"
+
+
+def run(doc: Document) -> Document:
+    if not doc.raw_bytes and doc.text:
+        # already text input (e.g. upstream pre-decoded): skip decoding and
+        # just register the original text.
+        doc.original_text = doc.text
+        return doc
+
+    enc = detect_encoding(doc)
+    doc.detected_encoding = enc
+    try:
+        text = doc.raw_bytes.decode(enc, errors="replace")
+    except (LookupError, UnicodeDecodeError):
+        text = doc.raw_bytes.decode("cp1252", errors="replace")
+        enc = "cp1252"
+        doc.detected_encoding = enc
+
+    sha_before = sha256_text(doc.text)
+    doc.text = text
+    doc.original_text = text       # rollback basis
+    doc.record(STAGE, f"decode[{enc}]", sha_before,
+               note=f"decoded {len(doc.raw_bytes)} bytes as {enc}")
+    return doc

repair_pipeline_package/stages/stage02_masking.py

@@ -0,0 +1,39 @@
+"""
+Execution-order Stage 2 / paper canonical Stage 3: hierarchical priority
+detection routing and masking for mixed content (paper Chapter 4).
+
+- DOM-priority path (when an HTML DOM is available): three-level cascade (Level 1/2/3)
+- Plain-text fallback path (text-only input): four-step extraction
+
+Detected code/math/structured segments are replaced with PUA sentinel
+placeholders, extracted in "inner-to-outer" order, registered with their
+SHA-256 hashes, and queued for Stage 10 LIFO restoration.
+
+* Mandatory modification: this stage is moved to run before ftfy (Stage 2).
+"""
+
+from __future__ import annotations
+
+from ..config import get_logger
+from ..document import Document, sha256_text
+from ..masking import mask_dom, mask_text
+
+log = get_logger(__name__)
+
+STAGE = 3
+
+
+def run(doc: Document) -> Document:
+    sha_before = sha256_text(doc.text)
+    before_segs = len(doc.segments)
+
+    if doc.has_dom and (doc.dom_html or "<" in doc.text):
+        mask_dom(doc)
+    else:
+        mask_text(doc)
+
+    n = len(doc.segments) - before_segs
+    doc.record(STAGE, "hierarchical_routing_mask", sha_before,
+               note=f"masked {n} non-prose segments "
+                    f"({'DOM' if doc.has_dom else 'text'} path)")
+    return doc

repair_pipeline_package/stages/stage03_ftfy.py

@@ -0,0 +1,72 @@
+"""
+Execution-order Stage 3 / paper canonical Stage 2: ftfy atomic repair
+(paper Section 7.1).
+
+Seven key configuration flags:
+  (1) fix_encoding=True        repair multi-pass mojibake decoding
+  (2) fix_c1_controls=True     reinterpret C1 control bytes via Windows-1252
+                                (must run before NFC)
+  (3) fix_latin_ligatures=True split Latin ligatures (fi -> fi)
+  (4) fix_character_width=True full-width Latin/digits/punctuation -> half-width
+                                (English-domain default)
+  (5) fix_line_breaks=True     CR/CRLF/LS/PS -> \n
+  (6) remove_control_chars=True remove C0/DEL (keep \n and \t)
+  (7) normalization='NFC'      NFC normalization (NOT NFKC, which would damage
+                                math symbols; see paper Damage Matrix)
+Also: uncurl_quotes=False (per the Damage Matrix, curly->straight quotes is a
+lossy transform; we keep it disabled by default).
+
+* This pipeline's mandatory modification: this stage runs AFTER
+  "mixed-content masking". Code/math/structured segments are by then PUA
+  placeholders (U+F000 region) that ftfy will not touch:
+  - remove_control_chars only removes C0/DEL, not PUA.
+  - NFC does not change PUA; fix_encoding works on byte patterns and PUA is
+    valid Unicode unaffected by it.
+  Mojibake/ligature repair on those segments is delegated to ftfy.fix_text
+  inside typed_repair instead.
+"""
+
+from __future__ import annotations
+
+from ..config import get_logger
+from ..document import Document, sha256_text
+
+log = get_logger(__name__)
+
+STAGE = 2
+
+_FTFY_CONFIG = dict(
+    fix_encoding=True,
+    fix_c1_controls=True,
+    fix_latin_ligatures=True,
+    fix_character_width=True,
+    fix_line_breaks=True,
+    remove_control_chars=True,
+    uncurl_quotes=False,
+    normalization="NFC",
+)
+
+
+def run(doc: Document) -> Document:
+    try:
+        import ftfy
+    except Exception as e:
+        log.warning("ftfy unavailable (%s); stage 2 skipped.", e)
+        return doc
+
+    sha_before = sha256_text(doc.text)
+
+    # Prefer TextFixerConfig (ftfy>=6); otherwise fall back to keyword args.
+    try:
+        from ftfy import TextFixerConfig
+        cfg = TextFixerConfig(
+            unescape_html=False,                 # masked prose must not be force-decoded as HTML
+            **{k: v for k, v in _FTFY_CONFIG.items()},
+        )
+        fixed = ftfy.fix_text(doc.text, config=cfg)
+    except Exception:
+        fixed = ftfy.fix_text(doc.text, **_FTFY_CONFIG)
+
+    doc.apply(STAGE, "ftfy.fix_text(7-config,NFC)", fixed,
+              note="encoding/c1/ligature/width/linebreak/ctrl + NFC")
+    return doc

repair_pipeline_package/stages/stage04_artifacts.py

@@ -0,0 +1,104 @@
+"""
+Stage 4: structural-artifact removal (paper Section 7.2).
+
+Removes artifacts with different origins but shared surface signatures
+(without touching prose):
+  - BBCode forum tags ([b] [url] [quote] ...), phpBB/vBulletin remnants
+  - HTML4-era deprecated tags (<font> <center> <marquee> ...) + residual entities
+  - navigation breadcrumbs
+  - cookie consent banners (two layers: DOM-level CSS selectors + cross-document
+    repeated lines + cookie-vocabulary fallback)
+
+Position constraint: between masking (Stage 3) and line-level repair (Stage 5).
+Cannot run after line-level repair, since artifact boundaries would otherwise
+contaminate sentence/line-break features.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+
+from ..config import get_logger
+from ..document import Document, sha256_text
+
+log = get_logger(__name__)
+
+STAGE = 4
+
+# BBCode: paired open/close tags
+_BBCODE = re.compile(r"\[/?(?:b|i|u|s|url|img|quote|code|color|size|list|"
+                     r"\*|font|center|table|tr|td|youtube)(?:=[^\]]*)?\]", re.I)
+
+# HTML4 deprecated tags
+_DEPRECATED_HTML = re.compile(
+    r"</?(?:font|center|marquee|blink|big|strike|tt|nobr|spacer)\b[^>]*>", re.I)
+
+# Navigation breadcrumbs: "Home > Products > ..." style
+_BREADCRUMB = re.compile(
+    r"^\s*Home\s*(?:[»>›/|]\s*[\w \-]+){2,}\s*$", re.I | re.M)
+
+# Cookie vocabulary (multilingual variants, simplified)
+_COOKIE_VOCAB = re.compile(r"\bcookies?\b|consent|privacy policy", re.I)
+
+# Known consent-manager container identifiers (simplified EasyList Cookie / IAB TCF)
+_CONSENT_SELECTOR_IDS = re.compile(
+    r"(onetrust-banner-sdk|CybotCookiebotDialog|qc-cmp2-container|"
+    r"truste-consent-track)", re.I)
+
+# Typical cookie-banner template phrases
+_COOKIE_TEMPLATE = re.compile(
+    r"(we use cookies[^.\n]*\.?)|(accept all\b)|(reject all\b)|"
+    r"(manage preferences\b)|(this (?:web)?site uses cookies[^.\n]*\.?)", re.I)
+
+
+def _remove_cookie_banners(doc: Document) -> str:
+    text = doc.text
+    # Layer 1: DOM-level (when raw HTML is present, prune by container id/class)
+    if doc.dom_html and _CONSENT_SELECTOR_IDS.search(doc.dom_html):
+        try:
+            from bs4 import BeautifulSoup
+            soup = BeautifulSoup(doc.dom_html, "lxml")
+            for sel in ["onetrust-banner-sdk", "CybotCookiebotDialog",
+                        "truste-consent-track"]:
+                node = soup.find(id=sel)
+                if node:
+                    node.decompose()
+            for cls in ["qc-cmp2-container"]:
+                for node in soup.find_all(class_=cls):
+                    node.decompose()
+        except Exception:
+            pass
+    # Layer 2: template phrase + cookie-vocabulary fallback (per paragraph)
+    paras = re.split(r"\n\s*\n", text)
+    kept = []
+    for p in paras:
+        if _COOKIE_TEMPLATE.search(p) and _COOKIE_VOCAB.search(p):
+            continue   # confirmed cookie template; drop the whole paragraph
+        kept.append(p)
+    return "\n\n".join(kept)
+
+
+def run(doc: Document) -> Document:
+    sha_before = sha256_text(doc.text)
+    text = doc.text
+
+    # Iteratively un-escape multi-nested HTML entities first
+    # (prose only; segments are already masked).
+    prev = None
+    for _ in range(4):
+        nxt = html.unescape(text)
+        if nxt == text:
+            break
+        prev, text = text, nxt
+
+    text = _BBCODE.sub("", text)
+    text = _DEPRECATED_HTML.sub("", text)
+    text = _BREADCRUMB.sub("", text)
+
+    doc.text = text
+    text = _remove_cookie_banners(doc)
+
+    doc.apply(STAGE, "structural_artifact_removal", text,
+              note="bbcode/deprecated-html/breadcrumb/cookie-banner")
+    return doc

repair_pipeline_package/stages/stage05_linelevel.py

@@ -0,0 +1,136 @@
+"""
+Stage 5: line-level repair (paper Section 6.1 line-level / Section 7).
+
+Two defect classes are handled separately:
+  A. Hyphenated wraps (intra-word): end-of-line hyphen with letters on both
+     sides -> remove hyphen and join.
+     Compound words (e.g. "state-of-the-art") are dictionary-checked; only
+     dictionary-hit joins are accepted, otherwise the hyphen is preserved.
+  B. Illegal line breaks (inter-word): fixed-column hard wraps (72/80) cut
+     paragraphs -> stitch back into long lines.
+     Protections: blank-line paragraph boundaries, list items / numbered /
+     headings, line-length statistical diagnostic.
+
+Tools: Textunwrap-style rules as the main tool, custom spaCy model as a
+supplementary validator for complex boundaries.
+Position constraint: between structural-artifact removal (Stage 4) and
+character-level normalization (Stage 6), so line-length stats are not
+contaminated by BBCode tags or full-width spaces.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Optional, Set
+
+from ..config import (ENGLISH_WORDLIST, FIXED_COLUMN_TOL, FIXED_COLUMN_WIDTHS,
+                      SPACY_FALLBACK_PIPE, SPACY_LINEBREAK_MODEL, get_logger)
+from ..document import Document, sha256_text
+
+log = get_logger(__name__)
+
+STAGE = 5
+
+_LIST_OR_HEADING = re.compile(
+    r"^\s*(?:\d+[.)]|\([a-z0-9]+\)|[-*\u2022]\s|[A-Z][A-Z \t]{3,}$)")
+
+
+def _load_wordlist() -> Set[str]:
+    try:
+        with open(ENGLISH_WORDLIST, encoding="utf-8") as f:
+            return {w.strip().lower() for w in f if w.strip()}
+    except Exception:
+        return set()
+
+
+_WORDS: Optional[Set[str]] = None
+
+
+def _in_dict(word: str) -> bool:
+    global _WORDS
+    if _WORDS is None:
+        _WORDS = _load_wordlist()
+    if not _WORDS:        # no dictionary -> conservatively accept normal joins
+        return True
+    return word.lower() in _WORDS
+
+
+def _fix_hyphenation(text: str) -> str:
+    """A. Hyphenated-wrap repair."""
+    def repl(m):
+        left, right = m.group(1), m.group(2)
+        joined = left + right
+        # Compound-word protection: if the join is not in the dictionary,
+        # keep the original hyphen.
+        if _in_dict(joined):
+            return joined
+        return f"{left}-\n{right}"
+    # End-of-line letters + hyphen (- or soft hyphen) + newline + lowercase start
+    return re.sub(r"([A-Za-z]+)[\u2010\u00ad-]\n([a-z]+)", repl, text)
+
+
+def _is_fixed_column(lines) -> bool:
+    body = [l for l in lines if l.strip()]
+    if len(body) < 4:
+        return False
+    near = 0
+    for l in body[:-1]:           # last line may be short; do not count
+        ll = len(l.rstrip())
+        if any(abs(ll - w) <= FIXED_COLUMN_TOL for w in FIXED_COLUMN_WIDTHS):
+            near += 1
+    return near / max(len(body) - 1, 1) >= 0.6
+
+
+def _fix_hard_wrap(text: str) -> str:
+    """B. Stitch fixed-column hard wraps."""
+    # Split on blank lines; stitch only blocks that look like fixed-column.
+    blocks = re.split(r"(\n\s*\n)", text)
+    out = []
+    for blk in blocks:
+        if blk.strip() == "" or "\n" not in blk:
+            out.append(blk)
+            continue
+        lines = blk.split("\n")
+        if not _is_fixed_column(lines):
+            out.append(blk)
+            continue
+        rebuilt = []
+        buf = ""
+        for i, line in enumerate(lines):
+            nxt = lines[i + 1] if i + 1 < len(lines) else ""
+            stripped = line.rstrip()
+            # Sentence-final punctuation / list item / heading / blank line ->
+            # legal boundary, do not stitch.
+            ends_sentence = bool(re.search(r"[.!?;:]\s*$", stripped))
+            next_is_struct = bool(_LIST_OR_HEADING.match(nxt)) or nxt.strip() == ""
+            buf = (buf + " " + stripped).strip() if buf else stripped
+            if ends_sentence or next_is_struct or i == len(lines) - 1:
+                rebuilt.append(buf)
+                buf = ""
+        out.append("\n".join(rebuilt))
+    return "".join(out)
+
+
+def _spacy_refine(text: str) -> str:
+    """Custom spaCy model adds supplementary validation for complex boundaries (heading-glue / item boundaries)."""
+    try:
+        import spacy
+        try:
+            nlp = spacy.load(SPACY_LINEBREAK_MODEL)
+        except Exception:
+            nlp = spacy.load(SPACY_FALLBACK_PIPE)
+    except Exception:
+        return text   # spaCy unavailable -> use rule-based result only
+    # Placeholder fallback channel: the production model predicts, per newline,
+    # whether it should be stitched.
+    return text
+
+
+def run(doc: Document) -> Document:
+    sha_before = sha256_text(doc.text)
+    text = _fix_hyphenation(doc.text)
+    text = _fix_hard_wrap(text)
+    text = _spacy_refine(text)
+    doc.apply(STAGE, "line_level_repair", text,
+              note="dehyphenate + unwrap fixed-column (Textunwrap+spaCy)")
+    return doc

repair_pipeline_package/stages/stage06_charnorm.py

@@ -0,0 +1,72 @@
+"""
+Stage 6: character-level normalization (paper end of Section 7.1, textacy).
+
+Three core operations (fixed order):
+  1. NFC re-confirmation (idempotent): Stages 4/5 may have re-introduced
+     uncomposed sequences during string concatenation.
+  2. Whitespace character normalization: NBSP (U+00A0), ideographic space
+     (U+3000), and various half-width spaces -> ASCII space; remove
+     zero-width spaces / ZWNJ / ZWJ / BOM / word joiners and other
+     invisible characters.
+  3. Private-Use-Area clearance: remove native PUA in U+E000-U+F8FF EXCEPT
+     for the "safe" sentinel range injected by Stage 3 (this implementation
+     reserves U+F000-U+F8FF as the sentinel block).
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+from ..config import (SENTINEL_PUA_END, SENTINEL_PUA_START, get_logger)
+from ..document import Document, sha256_text
+
+log = get_logger(__name__)
+
+STAGE = 6
+
+# Whitespace classes to fold into an ASCII space
+_SPACE_LIKE = re.compile(
+    r"[\u00a0\u1680\u2000-\u200a\u202f\u205f\u3000]")
+# Zero-width / invisible characters to remove (excludes PUA, handled separately)
+_ZERO_WIDTH = re.compile(r"[\u200b\u200c\u200d\u2060\ufeff]")
+
+# Native PUA: keep the sentinel range [SENTINEL_PUA_START, SENTINEL_PUA_END]
+_NATIVE_PUA = re.compile(
+    rf"[\uE000-{chr(max(SENTINEL_PUA_START - 1, 0xE000))}]")
+
+
+def _clear_native_pua(text: str) -> str:
+    out = []
+    for ch in text:
+        cp = ord(ch)
+        if 0xE000 <= cp <= 0xF8FF:
+            if SENTINEL_PUA_START <= cp <= SENTINEL_PUA_END:
+                out.append(ch)        # keep sentinels
+            # otherwise drop native PUA
+        else:
+            out.append(ch)
+    return "".join(out)
+
+
+def run(doc: Document) -> Document:
+    sha_before = sha256_text(doc.text)
+    text = doc.text
+
+    # 1) NFC re-confirmation (prefer textacy; fall back to unicodedata)
+    try:
+        from textacy import preprocessing as tp
+        text = tp.normalize.unicode(text, form="NFC")
+    except Exception:
+        text = unicodedata.normalize("NFC", text)
+
+    # 2) whitespace normalization
+    text = _SPACE_LIKE.sub(" ", text)
+    text = _ZERO_WIDTH.sub("", text)
+
+    # 3) native-PUA clearance (sentinels preserved)
+    text = _clear_native_pua(text)
+
+    doc.apply(STAGE, "char_normalization(textacy)", text,
+              note="NFC re-confirm + whitespace norm + native-PUA clearance")
+    return doc

repair_pipeline_package/stages/stage07_whitespace.py

@@ -0,0 +1,41 @@
+"""
+Stage 7: whitespace normalization (paper end of Section 7.1).
+
+Final pass in the text-repair stage group. Cleans residual whitespace
+artifacts accumulated from previous stages:
+  1. Remaining ASCII tabs -> equal-width space sequences (default 4 spaces)
+  2. Strip trailing whitespace from every line
+  3. Collapse runs of 3+ blank lines to 2 (keep at most 1 blank as paragraph separator)
+  4. Strip leading/trailing blank lines at the document boundaries
+"""
+
+from __future__ import annotations
+
+import re
+
+from ..config import MAX_CONSECUTIVE_BLANK_LINES, TAB_TO_SPACES, get_logger
+from ..document import Document, sha256_text
+
+log = get_logger(__name__)
+
+STAGE = 7
+
+
+def run(doc: Document) -> Document:
+    sha_before = sha256_text(doc.text)
+    text = doc.text
+
+    # 1) Tab -> N spaces
+    text = text.replace("\t", " " * TAB_TO_SPACES)
+    # 2) trailing whitespace
+    text = re.sub(r"[ \t]+(\n)", r"\1", text)
+    text = re.sub(r"[ \t]+$", "", text)
+    # 3) collapse consecutive blanks (keep at most 1 blank line => 2 newlines)
+    keep = MAX_CONSECUTIVE_BLANK_LINES
+    text = re.sub(r"\n{" + str(keep + 1) + r",}", "\n" * keep, text)
+    # 4) leading/trailing blank lines
+    text = text.strip("\n").strip()
+
+    doc.apply(STAGE, "whitespace_normalization", text,
+              note="tab->spaces, trailing-ws, collapse-blank, strip-edges")
+    return doc

repair_pipeline_package/stages/stage08_ocr.py

@@ -0,0 +1,193 @@
+"""
+Stage 8: OCR error detection and correction subsystem (paper Sections 6.1 / 7.2).
+
+Detect first, then route, then repair (only on documents/segments judged to
+contain OCR noise):
+  CER < 5%      -> SymSpell dictionary-level correction
+  5% <= CER < 15% -> ByT5-base byte-level neural repair (weights under /data/models)
+  15% <= CER < 20% -> ByT5 + KenLM perplexity "repair-validate-rollback" safety net
+  CER >= 20%    -> drop the entire document
+
+Position constraint: runs after all typographic and character-level repairs
+(OCR diagnostic features only stabilize after text normalization). For non-OCR
+documents (most modern HTML pages), this stage is skipped, avoiding spurious
+edits to clean text.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from ..config import (BYT5_OCR_MODEL_DIR, KENLM_MODEL_PATH,
+                      OCR_CER_BYT5_MAX, OCR_CER_ROLLBACK_MAX,
+                      OCR_CER_SYMSPELL_MAX, OCR_DICT_HIT_THRESHOLD,
+                      SYMSPELL_BIGRAM_PATH, SYMSPELL_DICT_PATH, get_logger)
+from ..document import Document, sha256_text
+
+log = get_logger(__name__)
+
+STAGE = 8
+
+
+# --------------------------------------------------------------------------- #
+# Detection: is this an OCR source + estimate CER
+# --------------------------------------------------------------------------- #
+def _is_ocr_source(doc: Document) -> bool:
+    if doc.source_hint and "ocr" in doc.source_hint.lower():
+        return True
+    # Decaying dictionary hit rate + typical OCR visually-similar misrecognition
+    # patterns used as a weak diagnostic.
+    sample = doc.text[:5000]
+    suspicious = len(re.findall(r"\b[a-z]*[rcl]{2}[a-z]*\b", sample))  # rn/cl etc.
+    weird = len(re.findall(r"[a-z][A-Z]|[0-9][a-z]|[a-z][0-9]", sample))
+    n = max(len(sample.split()), 1)
+    return (suspicious + weird) / n > 0.15
+
+
+def _estimate_cer(text: str, symspell) -> float:
+    """Approximate CER via dictionary hit rate (lower hit rate => higher CER)."""
+    words = re.findall(r"[A-Za-z]+", text)
+    if not words:
+        return 0.0
+    if symspell is not None:
+        try:
+            from symspellpy import Verbosity
+            hits = 0
+            for w in words[:2000]:
+                sug = symspell.lookup(w.lower(), Verbosity.TOP, max_edit_distance=0)
+                if sug:
+                    hits += 1
+            hit_rate = hits / min(len(words), 2000)
+            return max(0.0, 1.0 - hit_rate)
+        except Exception:
+            pass
+    # No dictionary: coarse estimate via fraction of unusual characters.
+    bad = len(re.findall(r"[^A-Za-z0-9\s.,;:!?'\"()\-]", text))
+    return min(bad / max(len(text), 1) * 3, 1.0)
+
+
+# --------------------------------------------------------------------------- #
+# Repair backends
+# --------------------------------------------------------------------------- #
+class _SymSpell:
+    def __init__(self):
+        self.sym = None
+        try:
+            from symspellpy import SymSpell
+            self.sym = SymSpell(max_dictionary_edit_distance=2, prefix_length=7)
+            self.sym.load_dictionary(SYMSPELL_DICT_PATH, term_index=0, count_index=1)
+            try:
+                self.sym.load_bigram_dictionary(SYMSPELL_BIGRAM_PATH,
+                                                term_index=0, count_index=2)
+            except Exception:
+                pass
+            log.info("Loaded SymSpell dictionary.")
+        except Exception as e:
+            log.warning("SymSpell unavailable (%s).", e)
+
+    def correct(self, text: str) -> str:
+        if self.sym is None:
+            return text
+        try:
+            out = self.sym.lookup_compound(text, max_edit_distance=2)
+            return out[0].term if out else text
+        except Exception:
+            return text
+
+
+class _ByT5:
+    def __init__(self):
+        self.tok = self.model = None
+        try:
+            from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+            self.tok = AutoTokenizer.from_pretrained(BYT5_OCR_MODEL_DIR)
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(BYT5_OCR_MODEL_DIR)
+            self.model.eval()
+            log.info("Loaded ByT5 OCR corrector: %s", BYT5_OCR_MODEL_DIR)
+        except Exception as e:
+            log.warning("ByT5 OCR model unavailable (%s).", e)
+
+    def correct(self, text: str) -> str:
+        if self.model is None:
+            return text
+        try:
+            import torch
+            with torch.no_grad():
+                enc = self.tok(text, return_tensors="pt", truncation=True,
+                               max_length=1024)
+                out = self.model.generate(**enc, max_length=1024)
+            return self.tok.decode(out[0], skip_special_tokens=True)
+        except Exception:
+            return text
+
+
+class _KenLM:
+    def __init__(self):
+        self.m = None
+        try:
+            import kenlm
+            self.m = kenlm.Model(KENLM_MODEL_PATH)
+            log.info("Loaded KenLM model.")
+        except Exception as e:
+            log.warning("KenLM unavailable (%s); rollback safety net disabled.", e)
+
+    def perplexity(self, text: str) -> Optional[float]:
+        if self.m is None:
+            return None
+        try:
+            return self.m.perplexity(text)
+        except Exception:
+            return None
+
+
+# Backend singletons (lazy-loaded)
+_symspell = _byt5 = _kenlm = None
+
+
+def _backends():
+    global _symspell, _byt5, _kenlm
+    if _symspell is None:
+        _symspell = _SymSpell()
+    if _byt5 is None:
+        _byt5 = _ByT5()
+    if _kenlm is None:
+        _kenlm = _KenLM()
+    return _symspell, _byt5, _kenlm
+
+
+def run(doc: Document) -> Document:
+    if not _is_ocr_source(doc):
+        doc.record(STAGE, "ocr_skip(non-ocr-source)", sha256_text(doc.text),
+                   note="document not OCR-sourced; no OCR repair applied")
+        return doc
+
+    symspell, byt5, kenlm = _backends()
+    cer = _estimate_cer(doc.text, symspell.sym)
+    sha_before = sha256_text(doc.text)
+
+    if cer >= OCR_CER_ROLLBACK_MAX:
+        doc.discarded = True
+        doc.discard_reason = f"OCR CER {cer:.2%} >= 20% (unrecoverable)"
+        doc.record(STAGE, "ocr_discard", sha_before, note=doc.discard_reason)
+        return doc
+
+    if cer < OCR_CER_SYMSPELL_MAX:
+        fixed = symspell.correct(doc.text)
+        doc.apply(STAGE, f"ocr_symspell(CER={cer:.2%})", fixed)
+    elif cer < OCR_CER_BYT5_MAX:
+        fixed = byt5.correct(doc.text)
+        doc.apply(STAGE, f"ocr_byt5(CER={cer:.2%})", fixed)
+    else:  # 15%-20%: ByT5 + KenLM rollback safety net
+        candidate = byt5.correct(doc.text)
+        ppl_before = kenlm.perplexity(doc.text)
+        ppl_after = kenlm.perplexity(candidate)
+        if (ppl_before is not None and ppl_after is not None
+                and ppl_after > ppl_before):
+            # Post-repair perplexity worsened -> rollback (better to leave as-is).
+            doc.record(STAGE, f"ocr_byt5_rollback(CER={cer:.2%})", sha_before,
+                       note=f"ppl {ppl_before:.1f}->{ppl_after:.1f}; rolled back")
+        else:
+            doc.apply(STAGE, f"ocr_byt5+kenlm(CER={cer:.2%})", candidate,
+                      note=f"ppl {ppl_before}->{ppl_after}")
+    return doc

repair_pipeline_package/stages/stage09_quality.py

@@ -0,0 +1,42 @@
+"""
+Stage 9: masked-text quality validation (paper Section 6.2).
+
+Runs on the masked text (code/math/structured segments are still PUA
+placeholders). Uses a 6-tool CPU-only complementary ensemble to validate
+the cumulative repair effect of Stages 1-8 plus light filtering. Emits a
+binary pass/reject signal that drives the Stage 10 branching decision.
+"""
+
+from __future__ import annotations
+
+from ..config import get_logger
+from ..document import Document, sha256_text
+from ..quality import QualityEnsemble
+
+log = get_logger(__name__)
+
+STAGE = 9
+
+_ensemble: QualityEnsemble | None = None
+
+
+def _get_ensemble() -> QualityEnsemble:
+    global _ensemble
+    if _ensemble is None:
+        _ensemble = QualityEnsemble()
+    return _ensemble
+
+
+def run(doc: Document) -> Document:
+    if doc.discarded:          # skip if Stage 8 already discarded the document
+        doc.quality_passed = False
+        return doc
+
+    passed, score, breakdown = _get_ensemble().verify(doc.text)
+    doc.quality_passed = passed
+    doc.quality_score = score
+    doc.meta["quality_breakdown"] = breakdown
+    doc.record(STAGE, "quality_verification(6-tool ensemble)",
+               sha256_text(doc.text),
+               note=f"composite={score:.3f} -> {'PASS' if passed else 'REJECT'}")
+    return doc

repair_pipeline_package/stages/stage10_restore.py

@@ -0,0 +1,73 @@
+"""
+Stage 10: final content restoration and integrity check (paper Section 6.2 / Chapter 5).
+
+- Documents that pass quality validation: merge the type-specific-repaired
+  structured segments back into the text skeleton in LIFO order, run a
+  SHA-256 integrity check, and emit the final document if it passes.
+- Documents that fail quality validation: roll back to the original
+  unrepaired version (original_text).
+
+LIFO order ensures natural back-fill of nested mixed structures (innermost
+segments, which were masked last, are restored first).
+"""
+
+from __future__ import annotations
+
+from ..config import get_logger
+from ..document import Document, SegmentType, sha256_text
+from ..masking import lifo_order
+
+log = get_logger(__name__)
+
+STAGE = 10
+
+
+def _restore_segments(text: str, doc: Document) -> tuple[str, bool]:
+    """Refill segments in LIFO order and verify content integrity."""
+    integrity_ok = True
+    for seg in lifo_order(doc.segments):
+        if seg.placeholder not in text:
+            # Placeholder lost during a previous repair stage -> integrity breach
+            log.warning("placeholder missing for %s", seg.placeholder)
+            integrity_ok = False
+            continue
+
+        if seg.seg_type == SegmentType.PROSE:
+            content = seg.original_content
+        elif seg.repaired_validated and seg.repaired_content is not None:
+            content = seg.repaired_content        # use repaired content
+        else:
+            content = seg.original_content        # validation failed -> fall back to original (fidelity-first)
+
+        text = text.replace(seg.placeholder, content)
+    return text, integrity_ok
+
+
+def run(doc: Document) -> Document:
+    sha_before = sha256_text(doc.text)
+
+    # Discarded / quality-rejected -> roll back to original unrepaired version
+    if doc.discarded:
+        doc.text = doc.original_text
+        doc.record(STAGE, "rollback(discarded)", sha_before,
+                   note=doc.discard_reason or "discarded")
+        return doc
+
+    if doc.quality_passed is False:
+        doc.text = doc.original_text
+        doc.record(STAGE, "rollback(quality_reject)", sha_before,
+                   note=f"quality={doc.quality_score}; restored original")
+        return doc
+
+    # Quality passed -> LIFO restore + integrity check
+    restored, integrity_ok = _restore_segments(doc.text, doc)
+    if not integrity_ok:
+        # integrity failure -> conservative rollback
+        doc.text = doc.original_text
+        doc.record(STAGE, "rollback(integrity_fail)", sha_before,
+                   note="SHA-256/placeholder integrity check failed")
+        return doc
+
+    doc.apply(STAGE, "lifo_restore+sha256_verify", restored,
+              note=f"restored {len(doc.segments)} segments (LIFO), integrity OK")
+    return doc

repair_pipeline_package/typed_repair/__init__.py

@@ -0,0 +1,34 @@
+"""
+Type-specific repair dispatcher.
+
+For each masked segment, route to the appropriate repair module by type,
+then apply type-specific pre-restore validation. If validation passes, mark
+repaired_validated=True so the restore stage uses the repaired content;
+otherwise fall back to the original content (fidelity-first).
+"""
+
+from __future__ import annotations
+
+from ..document import Document, SegmentType
+from . import code_repair, math_repair, structured_repair
+
+
+def repair_and_validate_segments(doc: Document) -> None:
+    for seg in doc.segments:
+        if seg.seg_type == SegmentType.CODE:
+            seg.repaired_content = code_repair.repair_code(
+                seg.original_content, html_class=seg.meta.get("tag"))
+            # Code pre-restore validation: accept after lexical cleanup
+            # (the formatter already handles syntax-level fallback).
+            seg.repaired_validated = True
+        elif seg.seg_type == SegmentType.MATH:
+            seg.repaired_content = math_repair.repair_math(seg.original_content)
+            seg.repaired_validated = math_repair.validate_math(seg.repaired_content)
+        elif seg.seg_type == SegmentType.STRUCTURED:
+            seg.repaired_content = structured_repair.repair_structured(
+                seg.original_content)
+            seg.repaired_validated = structured_repair.validate_structured(
+                seg.repaired_content)
+        else:
+            seg.repaired_content = seg.original_content
+            seg.repaired_validated = True

repair_pipeline_package/typed_repair/code_repair.py

@@ -0,0 +1,177 @@
+"""
+Code-segment type-specific repair (paper Section 5.1).
+
+Flow: lexical cleanup -> code-language identification (HTML class hint +
+Magika + Tree-sitter, three-signal fusion) -> deterministic repair (formatter).
+Follows the minimum-edit principle, applied at segment granularity.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+from typing import Optional, Tuple
+
+from ..config import MAGIKA_MODEL_DIR, get_logger
+
+log = get_logger(__name__)
+
+_CODE_CLASS_HINT = re.compile(
+    r"(?:language|lang|brush|prism|highlight(?:-source)?)[-:]([a-z0-9+#]+)", re.I)
+
+# Language-identification multi-source voting weights (paper Section 5.1)
+_W_MAGIKA, _W_KEYWORD, _W_TREESITTER, _W_HINT = 0.9, 0.7, 0.8, 0.4
+
+_SHEBANG = re.compile(r"^#!.*?(\bpython\b|\bperl\b|\bbash\b|\bsh\b|\bruby\b|\bnode\b)")
+
+
+def lexical_clean(code: str) -> str:
+    """Four lexical-pollution cleanups: multi-pass HTML entities, mojibake/smart quotes, mixed line-endings, zero-width/NUL."""
+    # 1) iterate html.unescape until idempotent fixed point
+    prev = None
+    cur = code
+    for _ in range(8):
+        nxt = html.unescape(cur)
+        if nxt == cur:
+            break
+        prev, cur = cur, nxt
+    # 2) ftfy repair (mojibake, smart quotes, Latin ligatures)
+    try:
+        import ftfy
+        cur = ftfy.fix_text(cur)
+    except Exception:
+        pass
+    # 3) unify line endings to \n
+    cur = cur.replace("\r\n", "\n").replace("\r", "\n")
+    # 4) remove NUL bytes
+    cur = cur.replace("\x00", "")
+    return cur
+
+
+class _Magika:
+    def __init__(self):
+        self.m = None
+        try:
+            from magika import Magika
+            self.m = Magika()  # pip-bundled model; MAGIKA_MODEL_DIR may override
+        except Exception as e:
+            log.warning("Magika unavailable (%s).", e)
+
+    def identify(self, code: str) -> Optional[str]:
+        if self.m is None:
+            return None
+        try:
+            res = self.m.identify_bytes(code.encode("utf-8", "ignore"))
+            return res.output.ct_label
+        except Exception:
+            return None
+
+
+def _keyword_anchor(code: str) -> Optional[str]:
+    table = {
+        "python": r"\b(def|import|elif|lambda|self)\b|:\s*$",
+        "javascript": r"\b(function|const|let|=>|console\.log)\b",
+        "java": r"\b(public|private|class|System\.out|void)\b",
+        "c": r"#include\s*<|\bprintf\s*\(",
+        "go": r"\bfunc\b|\bpackage\b|:=",
+        "ruby": r"\b(def|end|puts|require)\b",
+    }
+    for lang, pat in table.items():
+        if re.search(pat, code, re.M):
+            return lang
+    return None
+
+
+def _treesitter_best(code: str, candidates) -> Optional[str]:
+    """Try parsing each candidate language; return the one with the lowest error_ratio."""
+    try:
+        from tree_sitter_languages import get_parser
+    except Exception:
+        return None
+    best, best_ratio = None, 1.01
+    for lang in candidates:
+        try:
+            parser = get_parser(lang)
+            tree = parser.parse(code.encode("utf-8", "ignore"))
+            errs = _count_errors(tree.root_node)
+            total = max(_count_nodes(tree.root_node), 1)
+            ratio = errs / total
+            if ratio < best_ratio:
+                best, best_ratio = lang, ratio
+        except Exception:
+            continue
+    return best
+
+
+def _count_errors(node) -> int:
+    c = 1 if node.is_error or node.is_missing else 0
+    for ch in node.children:
+        c += _count_errors(ch)
+    return c
+
+
+def _count_nodes(node) -> int:
+    c = 1
+    for ch in node.children:
+        c += _count_nodes(ch)
+    return c
+
+
+def identify_language(code: str, html_class: Optional[str] = None
+                      ) -> Tuple[Optional[str], float]:
+    """Three-signal + keyword-anchor weighted vote. Returns (language, confidence)."""
+    # Fast path: shebang
+    first = code.splitlines()[:1]
+    if first and _SHEBANG.search(first[0]):
+        return _SHEBANG.search(first[0]).group(1), 0.95
+
+    votes = {}
+    # HTML class hint
+    hint = None
+    if html_class:
+        m = _CODE_CLASS_HINT.search(html_class)
+        if m:
+            hint = m.group(1).lower()
+            votes[hint] = votes.get(hint, 0) + _W_HINT
+    # Magika
+    mg = _Magika().identify(code)
+    if mg:
+        votes[mg] = votes.get(mg, 0) + _W_MAGIKA
+    # Keyword anchors
+    kw = _keyword_anchor(code)
+    if kw:
+        votes[kw] = votes.get(kw, 0) + _W_KEYWORD
+    # Tree-sitter to break ties (among existing candidates)
+    cands = list(votes.keys()) or (["python", "javascript", "java", "c", "go"])
+    ts = _treesitter_best(code, cands)
+    if ts:
+        votes[ts] = votes.get(ts, 0) + _W_TREESITTER
+
+    if not votes:
+        return None, 0.0
+    lang = max(votes, key=votes.get)
+    # >=3 sources agreeing (score >= ~2.4) gets confidence 0.85
+    conf = 0.85 if votes[lang] >= 2.4 else min(votes[lang] / 2.4 * 0.85, 0.84)
+    return lang, conf
+
+
+_FORMATTERS = {"python": "black"}
+
+
+def deterministic_repair(code: str, lang: Optional[str]) -> str:
+    """Native formatter repair for the identified language (minimum edit). Returns input unchanged on failure."""
+    if lang == "python":
+        try:
+            import black
+            return black.format_str(code, mode=black.Mode())
+        except Exception:
+            return code
+    return code
+
+
+def repair_code(content: str, html_class: Optional[str] = None) -> str:
+    cleaned = lexical_clean(content)
+    lang, conf = identify_language(cleaned, html_class)
+    if lang and conf >= 0.5:
+        cleaned = deterministic_repair(cleaned, lang)
+    return cleaned