Add verified text restoration

src/remove_ai_watermarks/_internal/qwen_zimage_pipeline.py

@@ -30,6 +30,8 @@ from remove_ai_watermarks._internal.watermark_profiles import resolve_seed
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+    from remove_ai_watermarks._internal.text_restoration import VerifiedTextManifest
+
 log = logging.getLogger(__name__)
 
 QWEN_IMAGE_2512_MODEL_ID = "Qwen/Qwen-Image-2512"
@@ -973,6 +975,30 @@ class QwenZImagePipeline:
             result = result.resize(image.size, Image.Resampling.LANCZOS)
         return result.convert("RGB")
 
+    def _qwen_vae_roundtrip(self, image: Image.Image) -> Image.Image:
+        """Reconstruct source pixels through the already loaded Qwen VAE."""
+        import torch
+
+        pipe, _controlnet_input_cls = self._load_qwen()
+        source_width, source_height = image.size
+        pad_width = (-source_width) % 8
+        pad_height = (-source_height) % 8
+        padded = image.convert("RGB")
+        if pad_width or pad_height:
+            padded = Image.fromarray(
+                np.pad(
+                    np.asarray(padded),
+                    ((0, pad_height), (0, pad_width), (0, 0)),
+                    mode="edge",
+                )
+            )
+        pipe.load_models_to_device(["vae"])
+        tensor = pipe.preprocess_image(padded).to(device=self.device, dtype=self.torch_dtype)
+        with torch.inference_mode():
+            latents = pipe.vae.encode(tensor)
+            decoded = pipe.vae.decode(latents)
+        return pipe.vae_output_to_image(decoded).crop((0, 0, source_width, source_height)).convert("RGB")
+
     @staticmethod
     def _detail_size(
         crop_size: tuple[int, int],
@@ -1044,10 +1070,15 @@ class QwenZImagePipeline:
         tile: bool = False,
         tile_size: int = 1024,
         tile_overlap: int = 128,
+        text_manifest: VerifiedTextManifest | None = None,
     ) -> Image.Image:
         """Execute global regeneration and masked face repair."""
         self._require_cuda()
         seed = resolve_seed(seed)
+        donor = None
+        if text_manifest is not None:
+            self._progress("Reconstructing the verified text donor with the Qwen VAE...")
+            donor = self._qwen_vae_roundtrip(image)
         global_strength = (
             resolution_adaptive_denoise(image.width, image.height) if strength is None else float(strength)
         )
@@ -1068,14 +1099,28 @@ class QwenZImagePipeline:
         boxes = detect_faces(image)
         if not boxes:
             self._progress("No faces detected; keeping the Qwen global result.")
-            return global_result
-        masks = self._sam_masks(image, boxes)
-        face_strength = largest_face_denoise(boxes, image.size) * FACE_DENOISE_SCALE
-        return self._run_faces(
-            image,
-            global_result,
-            boxes,
-            masks,
-            strength=face_strength,
-            seed=seed,
+            result = global_result
+        else:
+            masks = self._sam_masks(image, boxes)
+            face_strength = largest_face_denoise(boxes, image.size) * FACE_DENOISE_SCALE
+            result = self._run_faces(
+                image,
+                global_result,
+                boxes,
+                masks,
+                strength=face_strength,
+                seed=seed,
+            )
+        if text_manifest is None:
+            return result
+        if donor is None:
+            raise RuntimeError("Verified text restoration requires a Qwen-VAE donor")
+        from remove_ai_watermarks._internal.text_restoration import (
+            blend_fidelity_anchor,
+            restore_verified_text,
         )
+
+        self._progress("Blending the Qwen-VAE fidelity anchor...")
+        anchor = blend_fidelity_anchor(result, donor)
+        self._progress(f"Restoring {len(text_manifest.lines)} verified text lines...")
+        return restore_verified_text(image, anchor, donor, text_manifest.lines)

src/remove_ai_watermarks/_internal/text_restoration.py

@@ -0,0 +1,353 @@
+"""Opt-in restoration of verified text from a Qwen VAE reconstruction."""
+
+# pyright: reportUnknownMemberType=false, reportUnknownArgumentType=false, reportUnknownVariableType=false, reportUnknownParameterType=false, reportMissingTypeArgument=false, reportMissingTypeStubs=false, reportMissingImports=false, reportArgumentType=false, reportAssignmentType=false, reportReturnType=false, reportCallIssue=false, reportIndexIssue=false, reportOperatorIssue=false
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import cv2
+import numpy as np
+from PIL import Image
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from pathlib import Path
+
+    from numpy.typing import NDArray
+
+TEXT_MANIFEST_SCHEMA = 1
+FIDELITY_BLEND_ALPHA = 0.15
+GLYPH_FEATHER = 0.5
+
+
+@dataclass(frozen=True)
+class VerifiedTextLine:
+    """One operator-verified source line in source-pixel coordinates."""
+
+    box: tuple[int, int, int, int]
+    text: str
+    script: str
+    angle: float = 0.0
+
+
+@dataclass(frozen=True)
+class VerifiedTextManifest:
+    """Text annotations cryptographically bound to one decoded RGB source."""
+
+    source_pixel_sha256: str
+    width: int
+    height: int
+    lines: tuple[VerifiedTextLine, ...]
+
+
+def source_pixel_sha256(image: Image.Image) -> str:
+    """Hash decoded RGB geometry and bytes, independent of container metadata."""
+    rgb = image.convert("RGB")
+    digest = hashlib.sha256()
+    digest.update(rgb.width.to_bytes(8, "big"))
+    digest.update(rgb.height.to_bytes(8, "big"))
+    digest.update(rgb.tobytes())
+    return digest.hexdigest()
+
+
+def load_verified_text_manifest(path: Path, source: Image.Image) -> VerifiedTextManifest:
+    """Load and validate a manually verified manifest for exactly ``source``."""
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ValueError(f"Cannot read text manifest {path}: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise ValueError("Text manifest must be a JSON object")
+    if payload.get("schema_version") != TEXT_MANIFEST_SCHEMA:
+        raise ValueError(f"Text manifest schema_version must be {TEXT_MANIFEST_SCHEMA}")
+    if payload.get("verified") is not True:
+        raise ValueError("Text manifest must contain verified=true after manual review")
+
+    rgb = source.convert("RGB")
+    width = _manifest_integer(payload, "width")
+    height = _manifest_integer(payload, "height")
+    if (width, height) != rgb.size:
+        raise ValueError(f"Text manifest dimensions {width}x{height} do not match source {rgb.width}x{rgb.height}")
+    expected_hash = payload.get("source_pixel_sha256")
+    if not isinstance(expected_hash, str) or len(expected_hash) != 64:
+        raise ValueError("Text manifest source_pixel_sha256 must be a 64-character SHA-256")
+    actual_hash = source_pixel_sha256(rgb)
+    if expected_hash.casefold() != actual_hash:
+        raise ValueError("Text manifest source_pixel_sha256 does not match the decoded source pixels")
+
+    raw_lines = payload.get("lines")
+    if not isinstance(raw_lines, list) or not raw_lines:
+        raise ValueError("Text manifest lines must be a non-empty list")
+    lines = tuple(_load_line(item, width, height, index) for index, item in enumerate(raw_lines))
+    if list(lines) != sorted(lines, key=lambda line: (line.box[1], line.box[0])):
+        raise ValueError("Text manifest lines must be in top-to-bottom, left-to-right reading order")
+    return VerifiedTextManifest(actual_hash, width, height, lines)
+
+
+def _manifest_integer(payload: dict[str, Any], key: str) -> int:
+    value = payload.get(key)
+    if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
+        raise ValueError(f"Text manifest {key} must be a positive integer")
+    return value
+
+
+def _load_line(item: Any, width: int, height: int, index: int) -> VerifiedTextLine:
+    if not isinstance(item, dict):
+        raise ValueError(f"Text manifest line {index} must be an object")
+    raw_box = item.get("box")
+    if (
+        not isinstance(raw_box, list)
+        or len(raw_box) != 4
+        or any(isinstance(value, bool) or not isinstance(value, int) for value in raw_box)
+    ):
+        raise ValueError(f"Text manifest line {index} box must contain four integers")
+    box = tuple(raw_box)
+    x1, y1, x2, y2 = box
+    if not (0 <= x1 < x2 <= width and 0 <= y1 < y2 <= height):
+        raise ValueError(f"Text manifest line {index} box is outside the source dimensions")
+    text = item.get("text")
+    script = item.get("script")
+    if not isinstance(text, str) or not text.strip():
+        raise ValueError(f"Text manifest line {index} text must be non-empty")
+    if not isinstance(script, str) or not script.strip():
+        raise ValueError(f"Text manifest line {index} script must be non-empty")
+    angle_value = item.get("angle", 0.0)
+    if isinstance(angle_value, bool) or not isinstance(angle_value, int | float):
+        raise ValueError(f"Text manifest line {index} angle must be numeric")
+    angle = float(angle_value)
+    if not math.isfinite(angle) or abs(angle) > 30.0:
+        raise ValueError(f"Text manifest line {index} angle must be between -30 and 30 degrees")
+    return VerifiedTextLine(box, text, script, angle)
+
+
+def blend_fidelity_anchor(clean: Image.Image, donor: Image.Image) -> Image.Image:
+    """Blend 15% Qwen-VAE reconstruction into the oracle-clean pipeline output."""
+    clean_rgb = np.asarray(clean.convert("RGB"), dtype=np.float32)
+    donor_rgb = np.asarray(donor.convert("RGB"), dtype=np.float32)
+    if clean_rgb.shape != donor_rgb.shape:
+        raise ValueError("Clean result and Qwen-VAE donor dimensions must match")
+    blended = np.rint(clean_rgb * (1.0 - FIDELITY_BLEND_ALPHA) + donor_rgb * FIDELITY_BLEND_ALPHA)
+    return Image.fromarray(np.clip(blended, 0, 255).astype(np.uint8))
+
+
+def restore_verified_text(
+    source: Image.Image,
+    candidate: Image.Image,
+    donor: Image.Image,
+    lines: tuple[VerifiedTextLine, ...],
+) -> Image.Image:
+    """Erase candidate glyphs, then composite verified Qwen-VAE glyph cores."""
+    from remove_ai_watermarks import region_eraser
+
+    if not region_eraser.lama_available():
+        raise RuntimeError(
+            "Verified text restoration requires LaMa. Install: pip install 'remove-ai-watermarks[text-restoration]'"
+        )
+    source_rgb = np.asarray(source.convert("RGB"))
+    candidate_rgb = np.asarray(candidate.convert("RGB"))
+    donor_rgb = np.asarray(donor.convert("RGB"))
+    if source_rgb.shape != candidate_rgb.shape or source_rgb.shape != donor_rgb.shape:
+        raise ValueError("Source, candidate, and Qwen-VAE donor dimensions must match")
+
+    source_masks = [source_silhouette_mask(source_rgb, line.box, line.angle) for line in lines]
+    for index, mask in enumerate(source_masks):
+        if not np.any(mask):
+            raise ValueError(f"Verified text line {index} produced no source glyph pixels")
+    candidate_masks = [source_silhouette_mask(candidate_rgb, line.box, line.angle) for line in lines]
+    erase_masks = []
+    for line, source_mask, candidate_mask in zip(lines, source_masks, candidate_masks, strict=True):
+        radius = 5 if line.box[3] - line.box[1] >= 48 else 3
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2 * radius + 1,) * 2)
+        erase_masks.append(cv2.dilate(np.maximum(source_mask, candidate_mask), kernel))
+    del candidate_masks
+
+    groups = group_text_lines(lines)
+    background = cv2.cvtColor(candidate_rgb, cv2.COLOR_RGB2BGR)
+    for group in groups:
+        background = region_eraser.erase_lama(background, np.maximum.reduce([erase_masks[index] for index in group]))
+    background_rgb = cv2.cvtColor(background, cv2.COLOR_BGR2RGB)
+    residual_masks = [
+        residual_glyph_mask(background_rgb, mask, line.box) for line, mask in zip(lines, erase_masks, strict=True)
+    ]
+    for group in groups:
+        residual = np.maximum.reduce([residual_masks[index] for index in group])
+        if np.any(residual):
+            background = region_eraser.erase_lama(background, residual)
+    del erase_masks, residual_masks
+    restored = cv2.cvtColor(background, cv2.COLOR_BGR2RGB)
+    restored = composite_fresh_text_edges(source_rgb, restored, lines, source_masks)
+    source_glyph_mask = np.maximum.reduce(source_masks)
+    restored = composite_reconstructed_glyphs(donor_rgb, restored, source_glyph_mask)
+    return Image.fromarray(restored)
+
+
+def source_silhouette_mask(
+    source_rgb: NDArray[Any],
+    box: tuple[int, int, int, int],
+    angle: float = 0.0,
+) -> NDArray[Any]:
+    """Recover a thresholded glyph shape without retaining source amplitudes."""
+    height, width = source_rgb.shape[:2]
+    x1, y1, x2, y2 = _clip_box(box, width, height)
+    gray = cv2.cvtColor(source_rgb[y1:y2, x1:x2], cv2.COLOR_RGB2GRAY)
+    support = np.ones(gray.shape, dtype=np.uint8)
+    if angle:
+        box_width, box_height = x2 - x1, y2 - y1
+        theta = math.radians(abs(angle))
+        cosine, sine = math.cos(theta), math.sin(theta)
+        denominator = cosine * cosine - sine * sine
+        rect_width = (box_width * cosine - box_height * sine) / denominator
+        rect_height = (box_height * cosine - box_width * sine) / denominator
+        rotated = cv2.boxPoints(
+            ((box_width / 2, box_height / 2), (max(1.0, rect_width * 0.92), max(1.0, rect_height * 0.62)), -angle)
+        )
+        support.fill(0)
+        cv2.fillConvexPoly(support, np.rint(rotated).astype(np.int32), 1)
+        values = gray[support > 0]
+        background_luma = float(np.median(values))
+    else:
+        ring_pad = max(6, min(20, (y2 - y1) // 4))
+        rx1, ry1, rx2, ry2 = _clip_box((x1, y1, x2, y2), width, height, pad=ring_pad)
+        context = cv2.cvtColor(source_rgb[ry1:ry2, rx1:rx2], cv2.COLOR_RGB2GRAY)
+        ring = np.ones(context.shape, dtype=bool)
+        ring[y1 - ry1 : y2 - ry1, x1 - rx1 : x2 - rx1] = False
+        background_luma = float(np.median(context[ring])) if ring.any() else float(np.median(gray))
+        values = gray.reshape(-1)
+    low, high = float(np.percentile(values, 2)), float(np.percentile(values, 98))
+    dark_contrast, light_contrast = background_luma - low, high - background_luma
+    threshold = max(16.0, min(56.0, max(light_contrast, dark_contrast) * 0.22))
+    if light_contrast > dark_contrast:
+        crop_mask = (gray.astype(np.float32) >= background_luma + threshold).astype(np.uint8) * 255
+    else:
+        crop_mask = (gray.astype(np.float32) <= background_luma - threshold).astype(np.uint8) * 255
+    crop_mask[support == 0] = 0
+    result = np.zeros((height, width), dtype=np.uint8)
+    result[y1:y2, x1:x2] = crop_mask
+    return result
+
+
+def residual_glyph_mask(
+    background_rgb: NDArray[Any],
+    original_mask: NDArray[Any],
+    box: tuple[int, int, int, int],
+) -> NDArray[Any]:
+    """Find glyph-like contrast left after the first inpaint pass."""
+    residual = _foreground_mask(background_rgb, box)
+    residual = cv2.bitwise_and(residual, original_mask)
+    return cv2.dilate(residual, np.ones((5, 5), np.uint8), iterations=1)
+
+
+def composite_fresh_text_edges(
+    source_rgb: NDArray[Any],
+    background_rgb: NDArray[Any],
+    lines: tuple[VerifiedTextLine, ...],
+    masks: list[NDArray[Any]],
+) -> NDArray[Any]:
+    """Render fresh antialiased edges for source-derived glyph masks."""
+    restored = background_rgb
+    for line, mask in zip(lines, masks, strict=True):
+        color = _sample_text_color(source_rgb, mask, line.box)
+        restored = composite_fresh_silhouette(restored, mask, color)
+    return restored
+
+
+def composite_reconstructed_glyphs(
+    donor_rgb: NDArray[Any],
+    background_rgb: NDArray[Any],
+    glyph_mask: NDArray[Any],
+    *,
+    feather: float = GLYPH_FEATHER,
+) -> NDArray[Any]:
+    """Composite an exact reconstructed core with a narrow donor edge."""
+    if donor_rgb.shape != background_rgb.shape or donor_rgb.shape[:2] != glyph_mask.shape:
+        raise ValueError("donor, background, and glyph mask dimensions must match")
+    blurred = cv2.GaussianBlur(glyph_mask, (0, 0), feather) if feather > 0 else glyph_mask
+    alpha = np.maximum(glyph_mask, blurred).astype(np.float32) / 255.0
+    combined = donor_rgb.astype(np.float32) * alpha[..., None] + background_rgb.astype(np.float32) * (
+        1.0 - alpha[..., None]
+    )
+    return np.clip(np.rint(combined), 0, 255).astype(np.uint8)
+
+
+def composite_fresh_silhouette(
+    background_rgb: NDArray[Any],
+    glyph_mask: NDArray[Any],
+    color: tuple[int, int, int],
+    *,
+    feather: float = 0.35,
+) -> NDArray[Any]:
+    """Render a binary source shape with fresh color and antialiasing."""
+    if background_rgb.shape[:2] != glyph_mask.shape:
+        raise ValueError("background and glyph mask dimensions must match")
+    antialiased = cv2.GaussianBlur(glyph_mask, (0, 0), feather) if feather > 0 else glyph_mask
+    alpha = antialiased.astype(np.float32)[..., None] / 255.0
+    foreground = np.empty_like(background_rgb)
+    foreground[:, :] = color
+    combined = foreground.astype(np.float32) * alpha + background_rgb.astype(np.float32) * (1.0 - alpha)
+    return np.clip(combined, 0, 255).astype(np.uint8)
+
+
+def _clip_box(box: tuple[int, int, int, int], width: int, height: int, pad: int = 0) -> tuple[int, int, int, int]:
+    x1, y1, x2, y2 = box
+    return max(0, x1 - pad), max(0, y1 - pad), min(width, x2 + pad), min(height, y2 + pad)
+
+
+def _foreground_mask(source_rgb: NDArray[Any], box: tuple[int, int, int, int]) -> NDArray[Any]:
+    height, width = source_rgb.shape[:2]
+    line_height = box[3] - box[1]
+    x1, y1, x2, y2 = _clip_box(box, width, height, pad=max(6, int(line_height * 0.12)))
+    gray = cv2.cvtColor(source_rgb[y1:y2, x1:x2], cv2.COLOR_RGB2GRAY)
+    ring_pad = max(8, min(24, (y2 - y1) // 5))
+    rx1, ry1, rx2, ry2 = _clip_box((x1, y1, x2, y2), width, height, pad=ring_pad)
+    context = cv2.cvtColor(source_rgb[ry1:ry2, rx1:rx2], cv2.COLOR_RGB2GRAY)
+    ring = np.ones(context.shape, dtype=bool)
+    ring[y1 - ry1 : y2 - ry1, x1 - rx1 : x2 - rx1] = False
+    background_luma = float(np.median(context[ring])) if ring.any() else float(np.median(gray))
+    low, high = float(np.percentile(gray, 4)), float(np.percentile(gray, 96))
+    dark_contrast, light_contrast = background_luma - low, high - background_luma
+    threshold = max(24.0, min(72.0, max(light_contrast, dark_contrast) * 0.32))
+    if light_contrast > dark_contrast:
+        mask = (gray.astype(np.float32) >= background_luma + threshold).astype(np.uint8) * 255
+    else:
+        mask = (gray.astype(np.float32) <= background_luma - threshold).astype(np.uint8) * 255
+    mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, np.ones((2, 2), np.uint8))
+    dilation = 5 if line_height >= 48 else 3
+    mask = cv2.dilate(mask, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (2 * dilation + 1,) * 2))
+    result = np.zeros((height, width), dtype=np.uint8)
+    result[y1:y2, x1:x2] = mask
+    return result
+
+
+def _sample_text_color(
+    source_rgb: NDArray[Any], mask: NDArray[Any], box: tuple[int, int, int, int]
+) -> tuple[int, int, int]:
+    height, width = source_rgb.shape[:2]
+    x1, y1, x2, y2 = _clip_box(box, width, height, pad=2)
+    crop = source_rgb[y1:y2, x1:x2]
+    pixels = crop[mask[y1:y2, x1:x2] > 0]
+    luma = pixels.mean(axis=1)
+    background_luma = float(crop[[0, -1], :, :].reshape(-1, 3).mean(axis=1).mean())
+    selected = (
+        pixels[luma <= np.percentile(luma, 20)] if background_luma >= 128 else pixels[luma >= np.percentile(luma, 80)]
+    )
+    return tuple(int(value) for value in np.median(selected, axis=0))
+
+
+def group_text_lines(lines: Sequence[VerifiedTextLine]) -> list[list[int]]:
+    """Group nearby same-script lines for a shared LaMa erase pass."""
+    groups: list[list[int]] = []
+    for index, line in enumerate(lines):
+        if not groups:
+            groups.append([index])
+            continue
+        previous = lines[groups[-1][-1]]
+        gap = line.box[1] - previous.box[3]
+        if line.script != previous.script or gap > max(60, int((previous.box[3] - previous.box[1]) * 1.1)):
+            groups.append([index])
+        else:
+            groups[-1].append(index)
+    return groups

src/remove_ai_watermarks/_internal/watermark_remover.py

@@ -26,6 +26,8 @@ if TYPE_CHECKING:
     from collections.abc import Callable
     from pathlib import Path
 
+    from remove_ai_watermarks._internal.text_restoration import VerifiedTextManifest
+
 logger = logging.getLogger(__name__)
 
 try:
@@ -187,6 +189,7 @@ class WatermarkRemover:
         tile: bool = False,
         tile_size: int = 1024,
         tile_overlap: int = 128,
+        text_manifest: VerifiedTextManifest | None = None,
     ) -> Path:
         """Regenerate image pixels and write the result without AI metadata.
 
@@ -203,6 +206,10 @@ class WatermarkRemover:
         resolved_strength = resolve_strength(strength, vendor, self.model_profile, size=source.size)
         if not 0.0 <= resolved_strength <= 1.0:
             raise ValueError(f"Strength must be between 0.0 and 1.0, got {resolved_strength}")
+        if text_manifest is not None and self.model_profile == SDXL_ZIMAGE_PROFILE:
+            raise ValueError("Verified text restoration is supported only by the qwen-zimage profile")
+        if text_manifest is not None and tile:
+            raise ValueError("Verified text restoration is not calibrated with tiled diffusion")
 
         result = self._load_qwen_zimage_pipeline().run(
             source,
@@ -211,6 +218,7 @@ class WatermarkRemover:
             tile=tile,
             tile_size=tile_size,
             tile_overlap=tile_overlap,
+            text_manifest=text_manifest,
         )
         self._write_output(result, destination)
         return destination

src/remove_ai_watermarks/api.py

@@ -243,6 +243,7 @@ class InvisibleOptions:
     tile: bool = False
     tile_size: int = 1024
     tile_overlap: int = 128
+    text_manifest: Path | None = None
 
 
 # What the invisible stage did. "unavailable" is the one outcome the caller must
@@ -523,6 +524,7 @@ def _run_invisible(
         tile=opts.tile,
         tile_size=opts.tile_size,
         tile_overlap=opts.tile_overlap,
+        text_manifest=opts.text_manifest,
     )
     say("invisible", "removed")
     return "removed"

src/remove_ai_watermarks/cli.py

@@ -311,6 +311,16 @@ _cpu_offload_option = click.option(
     ),
 )
 
+_text_manifest_option = click.option(
+    "--text-manifest",
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    default=None,
+    help=(
+        "Experimental verified-text restoration manifest. Requires qwen-zimage, "
+        "the text-restoration extra, native untiled geometry, and no postprocessing."
+    ),
+)
+
 
 _visible_backend_option = click.option(
     "--backend",
@@ -787,6 +797,7 @@ def cmd_erase(
 @_tile_options
 @_force_option
 @_cpu_offload_option
+@_text_manifest_option
 @click.pass_context
 def cmd_invisible(
     ctx: click.Context,
@@ -806,6 +817,7 @@ def cmd_invisible(
     tile_overlap: int,
     force: bool,
     cpu_offload: bool,
+    text_manifest: Path | None,
 ) -> None:
     """Remove invisible AI watermarks (SynthID, StableSignature, TreeRing).
 
@@ -853,20 +865,25 @@ def cmd_invisible(
     console.print(f"  Strength: {_resolved_strength_for_display(source, strength, vendor, pipeline)}")
 
     t0 = time.monotonic()
-    result_path = engine.remove_watermark(
-        image_path=source,
-        output_path=output,
-        strength=strength,
-        seed=seed,
-        humanize=humanize,
-        unsharp=unsharp,
-        adaptive_polish=adaptive_polish,
-        max_resolution=max_resolution,
-        vendor=vendor,
-        tile=tile,
-        tile_size=tile_size,
-        tile_overlap=tile_overlap,
-    )
+    try:
+        result_path = engine.remove_watermark(
+            image_path=source,
+            output_path=output,
+            strength=strength,
+            seed=seed,
+            humanize=humanize,
+            unsharp=unsharp,
+            adaptive_polish=adaptive_polish,
+            max_resolution=max_resolution,
+            vendor=vendor,
+            tile=tile,
+            tile_size=tile_size,
+            tile_overlap=tile_overlap,
+            text_manifest=text_manifest,
+        )
+    except (OSError, RuntimeError, ValueError) as exc:
+        console.print(f"  Error: {exc}")
+        raise SystemExit(1) from exc
     elapsed = time.monotonic() - t0
 
     size_kb = result_path.stat().st_size / 1024
@@ -1410,6 +1427,7 @@ def cmd_identify(ctx: click.Context, source: Path, no_visible: bool, as_json: bo
 @_tile_options
 @_force_option
 @_cpu_offload_option
+@_text_manifest_option
 @click.pass_context
 def cmd_all(
     ctx: click.Context,
@@ -1431,6 +1449,7 @@ def cmd_all(
     tile_overlap: int,
     force: bool,
     cpu_offload: bool,
+    text_manifest: Path | None,
 ) -> None:
     """Remove ALL watermarks: visible + invisible + metadata.
 
@@ -1508,6 +1527,7 @@ def cmd_all(
                 tile=tile,
                 tile_size=tile_size,
                 tile_overlap=tile_overlap,
+                text_manifest=text_manifest,
             ),
             force=force,
             progress=progress,

src/remove_ai_watermarks/invisible_engine.py

@@ -18,6 +18,7 @@ from typing import TYPE_CHECKING
 
 from ._internal.watermark_profiles import (
     DEFAULT_PROFILE,
+    QWEN_ZIMAGE_PROFILE,
     REMOVAL_MODULES,
     resolve_adaptive_polish,
     resolve_seed,
@@ -148,6 +149,7 @@ class InvisibleEngine:
         tile: bool = False,
         tile_size: int = 1024,
         tile_overlap: int = 128,
+        text_manifest: Path | None = None,
     ) -> Path:
         """Remove invisible watermark from an image.
 
@@ -180,6 +182,11 @@ class InvisibleEngine:
                 Engages only when the long side exceeds ``tile_size``.
             tile_size: Tile dimension in px (default 1024).
             tile_overlap: Overlap between adjacent tiles in px (default 128).
+            text_manifest: Operator-verified text lines bound to the decoded source
+                pixels. Enables the experimental Qwen-VAE ``vae-glyphs`` post-pass.
+                Requires the ``text-restoration`` extra and the ``qwen-zimage``
+                profile. Incompatible with tiling, downscaling, humanize, unsharp,
+                and adaptive polish because those combinations are not calibrated.
 
         Returns:
             Path to the cleaned image.
@@ -189,6 +196,23 @@ class InvisibleEngine:
         seed = resolve_seed(seed)
         adaptive_polish = resolve_adaptive_polish(adaptive_polish, self._remover.model_profile)
 
+        if text_manifest is not None:
+            if self._remover.model_profile != QWEN_ZIMAGE_PROFILE:
+                raise ValueError("--text-manifest is supported only by the qwen-zimage profile")
+            if max_resolution != 0:
+                raise ValueError("--text-manifest requires --max-resolution 0")
+            if tile:
+                raise ValueError("--text-manifest is not calibrated with --tile")
+            if humanize > 0.0 or unsharp > 0.0 or adaptive_polish:
+                raise ValueError("--text-manifest requires humanize=0, unsharp=0, and adaptive polish disabled")
+            from remove_ai_watermarks import region_eraser
+
+            if not region_eraser.lama_available():
+                raise RuntimeError(
+                    "Verified text restoration requires LaMa. Install: "
+                    "pip install 'remove-ai-watermarks[text-restoration]'"
+                )
+
         from PIL import Image, ImageOps
 
         # Resolution policy: a max_resolution cap (0 = none) bounds memory on huge
@@ -205,6 +229,11 @@ class InvisibleEngine:
         # Full-res original, kept for the adaptive-polish detail target (image is
         # reassigned to the resized copy below; PIL resize returns a new object).
         reference_pil = image
+        verified_text = None
+        if text_manifest is not None:
+            from remove_ai_watermarks._internal.text_restoration import load_verified_text_manifest
+
+            verified_text = load_verified_text_manifest(text_manifest, reference_pil)
 
         # Both profiles run at the input's native geometry, so only the explicit max
         # cap can move it, and it can only ever scale down.
@@ -240,6 +269,7 @@ class InvisibleEngine:
                 tile=tile,
                 tile_size=tile_size,
                 tile_overlap=tile_overlap,
+                text_manifest=verified_text,
             )
 
             # Post-processing chain: decode the diffusion output ONCE, apply the