Fix: hard mask (no ghost blending) + pad 8px + old pipeline

app.py

@@ -1,5 +1,6 @@
 """
-MangaCleaner GPU Microservice — app.py
+MangaCleaner GPU Microservice — app.py
+# v2-fixed: Hard mask blending (no ghost text), safe HF download, reduced pad
 Space: mmo9/Inpainting_bot
 GPU: RTX Pro 6000 Blackwell (48 GB VRAM) — Persistent Pro GPU / ZeroGPU
 
@@ -215,8 +216,6 @@ else:
 # Switched to segmentation model — returns pixel masks instead of bounding boxes
 YOLO_REPO        = "ogkalu/comic-text-segmenter-yolov8m"
 YOLO_FILE        = "comic-text-segmenter.pt"
-TEXT_DETECTOR_REPO = "deepghs/AnimeText_yolo"
-TEXT_DETECTOR_FILE = "yolo12n_animetext/model.pt"
 # AOT-GAN: manga-image-translator AOT inpainting (SafeTensors, 22MB)
 # Replaces LaMa — trained on manga/comic, far better at screentones & gradients
 AOT_REPO         = "mayocream/aot-inpainting"
@@ -237,37 +236,25 @@ BLUR_RADIUS    = int(os.getenv("BLUR_RADIUS",      "19"))
 MAX_ZIP_MB     = int(os.getenv("MAX_ZIP_MB",       "500"))
 # Minimum connected component area (px²) to keep — removes screentone/noise dots
 MIN_COMP_AREA  = int(os.getenv("MIN_COMP_AREA",   "20"))
-SAFE_BUBBLE_BORDER = int(os.getenv("SAFE_BUBBLE_BORDER", "5"))
-UNIFORM_LIGHT_STD = float(os.getenv("UNIFORM_LIGHT_STD", "12"))
-UNIFORM_LIGHT_GRADIENT = float(os.getenv("UNIFORM_LIGHT_GRADIENT", "8"))
-COMPLEX_FEATHER_RADIUS = float(os.getenv("COMPLEX_FEATHER_RADIUS", "2.5"))
 
 # Global model handles
 yolo_model: Optional[YOLO] = None
-text_detector_model: Optional[YOLO] = None
 lama_session: Optional[ort.InferenceSession] = None  # kept for compat, not used for inference
 aot_model = None  # AOT-GAN removed — not used
 bubble_seg_model: Optional[YOLO] = None
+sd_pipe = None   # StableDiffusionInpaintPipeline for background reconstruction
 
 
-# ——————————————————————————————————————————————————
+# ──────────────────────────────────────────────
 # Model Loading Helper (Lazy Loading on First Use)
-# ——————————————————————————————————————————————————
-def _safe_download(repo_id: str, filename: str) -> str:
-    try:
-        return hf_hub_download(repo_id=repo_id, filename=filename, local_files_only=False)
-    except Exception as e:
-        log.warning("Online hf_hub_download for %s/%s failed (%s), trying local cache...", repo_id, filename, e)
-        return hf_hub_download(repo_id=repo_id, filename=filename, local_files_only=True)
-
-
+# ──────────────────────────────────────────────
 def ensure_models_loaded():
-    global yolo_model, text_detector_model, lama_session, aot_model, bubble_seg_model
+    global yolo_model, lama_session, aot_model, bubble_seg_model, sd_pipe
 
     if yolo_model is None:
         log.info("Loading YOLOv8 text segmenter …")
         try:
-            yolo_path = _safe_download(repo_id=YOLO_REPO, filename=YOLO_FILE)
+            yolo_path = hf_hub_download(repo_id=YOLO_REPO, filename=YOLO_FILE)
             yolo_model = YOLO(yolo_path)
             if torch.cuda.is_available():
                 try:
@@ -278,27 +265,10 @@ def ensure_models_loaded():
         except Exception as exc:
             log.error("YOLO load failed: %s", exc)
 
-    if text_detector_model is None:
-        log.info("Loading AnimeText text detector …")
-        try:
-            text_detector_path = _safe_download(
-                repo_id=TEXT_DETECTOR_REPO,
-                filename=TEXT_DETECTOR_FILE,
-            )
-            text_detector_model = YOLO(text_detector_path)
-            if torch.cuda.is_available():
-                try:
-                    text_detector_model.to(0)
-                except Exception:
-                    pass
-            log.info("AnimeText text detector loaded successfully.")
-        except Exception as exc:
-            log.error("AnimeText detector load failed: %s", exc)
-
     if lama_session is None:
         log.info("Loading LaMa ONNX model …")
         try:
-            lama_path = _safe_download(repo_id=LAMA_REPO, filename=LAMA_FILE)
+            lama_path = hf_hub_download(repo_id=LAMA_REPO, filename=LAMA_FILE)
             providers = ["CPUExecutionProvider"]
             if torch.cuda.is_available() or "CUDAExecutionProvider" in ort.get_available_providers():
                 providers.insert(0, ("CUDAExecutionProvider", {"device_id": 0}))
@@ -315,7 +285,7 @@ def ensure_models_loaded():
     if bubble_seg_model is None:
         log.info("Loading bubble segmentation model (manga109-segmentation-bubble) ...")
         try:
-            bubble_seg_path = hf_hub_download(repo_id=BUBBLE_SEG_REPO, filename=BUBBLE_SEG_FILE, local_files_only=True)
+            bubble_seg_path = hf_hub_download(repo_id=BUBBLE_SEG_REPO, filename=BUBBLE_SEG_FILE)
             bubble_seg_model = YOLO(bubble_seg_path)
             if torch.cuda.is_available():
                 try:
@@ -326,6 +296,27 @@ def ensure_models_loaded():
         except Exception as exc:
             log.error("Bubble seg model load failed (non-fatal): %s", exc)
 
+    if sd_pipe is None:
+        log.info("Loading Stable Diffusion 2 Inpainting pipeline ...")
+        try:
+            from diffusers import StableDiffusionInpaintPipeline
+            sd_pipe = StableDiffusionInpaintPipeline.from_pretrained(
+                "stabilityai/stable-diffusion-2-inpainting",
+                torch_dtype=torch.float16,
+                safety_checker=None,
+                requires_safety_checker=False,
+            )
+            sd_pipe = sd_pipe.to("cuda")
+            sd_pipe.set_progress_bar_config(disable=True)
+            # Speed optimisations
+            sd_pipe.enable_attention_slicing()
+            log.info("SD2 Inpainting pipeline loaded on CUDA")
+        except Exception as exc:
+            log.error("SD2 Inpainting load failed (will fall back to Telea): %s", exc)
+            sd_pipe = None
+
+
+
 def _cuda_available() -> bool:
     try:
         import torch
@@ -689,19 +680,20 @@ def _build_text_mask(image_bgr: np.ndarray, dilate_iter: int = 3, remove_sfx: bo
     h, w = image_bgr.shape[:2]
     mask = np.zeros((h, w), dtype=np.uint8)
 
-    if text_detector_model is None:
+    if yolo_model is None:
         return mask
 
     # Base confidence threshold for speech bubbles (0.15 for high recall)
     conf_thresh_predict = 0.15
 
     # Determine task type (detect or segment)
-    task_type = getattr(text_detector_model, "task", "detect")
+    task_type = getattr(yolo_model, "task", "detect")
     
-    # NOTE: text_detector_model = AnimeText (single class: text regions only, no SFX class).
-    # The allowed_classes SFX filter is ONLY for comic-text-segmenter (yolo_model), which has:
-    # 0: balloon, 1: qipao, 2: fangkuai, 3: changfangtiao, 4: kuangwai (free text/SFX), 5: other
-    # AnimeText has different class IDs - do NOT filter by class for it.
+    # ogkalu/comic-text-segmenter-yolov8m classes:
+    # 0: balloon, 1: qipao, 2: fangkuai, 3: changfangtiao, 4: kuangwai (free text/SFX/narration), 5: other
+    bubble_classes = {0, 1, 2, 3}
+    sfx_classes = {4, 5}
+
     def _check_conf(c_int: int, conf: float, base_conf: float) -> bool:
         return conf >= base_conf
 
@@ -709,7 +701,7 @@ def _build_text_mask(image_bgr: np.ndarray, dilate_iter: int = 3, remove_sfx: bo
         pass_mask = np.zeros((h, w), dtype=np.uint8)
         dev_target = 0 if torch.cuda.is_available() else "cpu"
         if h / w < 2.0:
-            results = text_detector_model.predict(
+            results = yolo_model.predict(
                 source=image_bgr[:, :, ::-1],
                 conf=conf_val,
                 iou=YOLO_IOU,
@@ -742,7 +734,7 @@ def _build_text_mask(image_bgr: np.ndarray, dilate_iter: int = 3, remove_sfx: bo
             stride = tile_h - overlap
             
             if w <= 300 or stride <= 0:
-                results = text_detector_model.predict(
+                results = yolo_model.predict(
                     source=image_bgr[:, :, ::-1],
                     conf=conf_val,
                     iou=YOLO_IOU,
@@ -777,7 +769,7 @@ def _build_text_mask(image_bgr: np.ndarray, dilate_iter: int = 3, remove_sfx: bo
                     if tile_h_actual == 0 or tile_w == 0:
                         break
                         
-                    results = text_detector_model.predict(
+                    results = yolo_model.predict(
                         source=tile_img[:, :, ::-1],
                         conf=conf_val,
                         iou=YOLO_IOU,
@@ -823,175 +815,6 @@ def _build_text_mask(image_bgr: np.ndarray, dilate_iter: int = 3, remove_sfx: bo
         mask = cv2.dilate(mask, kernel, iterations=max(2, dilate_iter))
     return mask
 
-
-def _safe_bubble_interior(interior: np.ndarray) -> np.ndarray:
-    """Shrink a bubble mask so outlines, tails, and adjacent artwork stay untouched."""
-    if interior is None or interior.max() == 0:
-        return np.zeros_like(interior) if interior is not None else np.empty((0, 0), dtype=np.uint8)
-    border = max(1, SAFE_BUBBLE_BORDER)
-    kernel_size = border * 2 + 1
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
-    return cv2.erode(
-        interior,
-        kernel,
-        iterations=1,
-        borderType=cv2.BORDER_CONSTANT,
-        borderValue=0,
-    )
-
-
-def _component_background_is_uniform_light(img_rgb: np.ndarray, component: np.ndarray, allowed: np.ndarray) -> bool:
-    """Return true only for a genuinely flat, light local background.
-
-    This intentionally errs on the side of treating a region as complex.  A gradient
-    bubble must never be sent to the white-bubble path merely because it is bright.
-    """
-    outer = cv2.dilate(component, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (17, 17)), iterations=1)
-    inner = cv2.dilate(component, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)), iterations=1)
-    ring = cv2.subtract(outer, inner)
-    if allowed is not None and allowed.max() > 0:
-        ring = cv2.bitwise_and(ring, allowed)
-    pixels = img_rgb[ring > 0]
-    if len(pixels) < 32:
-        return False
-
-    gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
-    gradient = cv2.magnitude(
-        cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3),
-        cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3),
-    )
-    gradient_mean = float(gradient[ring > 0].mean())
-    lightness = pixels.mean(axis=1)
-    return (
-        float(lightness.mean()) >= 220.0
-        and float(lightness.std()) <= UNIFORM_LIGHT_STD
-        and float(pixels.std(axis=0).mean()) <= UNIFORM_LIGHT_STD
-        and gradient_mean <= UNIFORM_LIGHT_GRADIENT
-    )
-
-
-def _find_system_panel_interior(img_rgb: np.ndarray, component: np.ndarray) -> np.ndarray:
-    """Find a bordered rectangular panel enclosing a text block, if present."""
-    height, width = component.shape
-    contours, _ = cv2.findContours(component, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not contours:
-        return np.zeros_like(component)
-    text_x, text_y, text_width, text_height = cv2.boundingRect(max(contours, key=cv2.contourArea))
-    pad_x = max(40, int(text_width * 0.8))
-    pad_y = max(35, int(text_height * 1.5))
-    x0, y0 = max(0, text_x - pad_x), max(0, text_y - pad_y)
-    x1, y1 = min(width, text_x + text_width + pad_x), min(height, text_y + text_height + pad_y)
-    roi = cv2.cvtColor(img_rgb[y0:y1, x0:x1], cv2.COLOR_RGB2GRAY)
-    edges = cv2.Canny(roi, 60, 150)
-    panel_candidates, _ = cv2.findContours(edges, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
-    selected = None
-    selected_area = None
-    for contour in panel_candidates:
-        x, y, candidate_width, candidate_height = cv2.boundingRect(contour)
-        gx, gy = x0 + x, y0 + y
-        if candidate_width < text_width * 1.25 or candidate_height < text_height * 1.5:
-            continue
-        if gx > text_x or gy > text_y or gx + candidate_width < text_x + text_width or gy + candidate_height < text_y + text_height:
-            continue
-        ratio = candidate_width / max(1, candidate_height)
-        if ratio < 0.35 or ratio > 8.0:
-            continue
-        area = candidate_width * candidate_height
-        if selected_area is None or area < selected_area:
-            selected = (gx, gy, candidate_width, candidate_height)
-            selected_area = area
-
-    panel = np.zeros_like(component)
-    if selected is None:
-        return panel
-    x, y, candidate_width, candidate_height = selected
-    border = min(10, max(3, min(candidate_width, candidate_height) // 16))
-    if candidate_width <= border * 2 or candidate_height <= border * 2:
-        return panel
-    cv2.rectangle(
-        panel,
-        (x + border, y + border),
-        (x + candidate_width - border, y + candidate_height - border),
-        255,
-        thickness=-1,
-    )
-    return panel
-
-
-def _route_text_masks(img_rgb: np.ndarray, legacy_mask: np.ndarray, bubble_interior: np.ndarray, allow_external: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-    """Route text mask into legacy (LaMa / fast fill) and complex (LaMa ONNX) inpainting.
-    Guarantees that detected text in manhwa/webtoons is ALWAYS cleaned.
-    """
-    legacy = np.zeros_like(legacy_mask)
-    complex_mask = np.zeros_like(legacy_mask)
-    excluded = np.zeros_like(legacy_mask)
-
-    if legacy_mask is None or legacy_mask.max() == 0:
-        return legacy, complex_mask, excluded
-
-    contours, _ = cv2.findContours(legacy_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-
-    for contour in contours:
-        component = np.zeros_like(legacy_mask)
-        cv2.drawContours(component, [contour], -1, 255, thickness=-1)
-
-        uniform_region = _component_background_is_uniform_light(
-            img_rgb,
-            component,
-            bubble_interior,
-        )
-
-        if uniform_region:
-            legacy = cv2.bitwise_or(legacy, component)
-        else:
-            complex_mask = cv2.bitwise_or(complex_mask, component)
-
-    return legacy, complex_mask, excluded
-
-
-def _prepare_cleaning_masks(img_bgr: np.ndarray, img_rgb: np.ndarray, dilate_iter: int, remove_sfx: bool, c_constant: int) -> dict[str, np.ndarray]:
-    coarse_mask = _build_text_mask(img_bgr, dilate_iter=dilate_iter, remove_sfx=remove_sfx)
-    empty_mask = np.zeros(img_bgr.shape[:2], dtype=np.uint8)
-    if coarse_mask.max() == 0:
-        return {
-            "coarse": empty_mask,
-            "precise": empty_mask,
-            "bubble_interior": empty_mask,
-            "legacy": empty_mask,
-            "complex": empty_mask,
-            "excluded": empty_mask,
-        }
-
-    precise_mask = _extract_precise_text_mask(img_rgb, coarse_mask, c_constant=c_constant)
-    final_mask = precise_mask
-    bubble_interior = _build_bubble_interior_mask(img_bgr)
-    legacy_mask, complex_mask, excluded_mask = _route_text_masks(
-        img_rgb,
-        final_mask,
-        bubble_interior,
-        allow_external=remove_sfx,
-    )
-    return {
-        "coarse": coarse_mask,
-        "precise": final_mask,
-        "bubble_interior": bubble_interior,
-        "legacy": legacy_mask,
-        "complex": complex_mask,
-        "excluded": excluded_mask,
-    }
-
-def _hybrid_inpaint(img_rgb: np.ndarray, mask: np.ndarray) -> np.ndarray:
-    """Inpaint img_rgb using LaMa ONNX Neural Inpainting for ALL text regions.
-    Seamlessly reconstructs speech bubble gradients, system windows, dark aura boxes,
-    and complex backgrounds without blocky solid color patches or white blobs.
-    """
-    if mask is None or mask.max() == 0:
-        return img_rgb
-
-    # Run LaMa ONNX Neural Inpainter on the full text mask
-    out = _lama_inpaint_tile(img_rgb, mask)
-    return out
-
 def _hybrid_inpaint(img_rgb: np.ndarray, mask: np.ndarray) -> np.ndarray:
     """Inpaint img_rgb using LaMa ONNX Neural Inpainting for ALL text regions.
     Seamlessly reconstructs speech bubble gradients, system windows, dark aura boxes,
@@ -1017,49 +840,26 @@ def _build_bubble_interior_mask(image_bgr: np.ndarray) -> np.ndarray:
     try:
         task_type = getattr(bubble_seg_model, "task", "segment")
         dev_target = 0 if torch.cuda.is_available() else "cpu"
-
-        def add_tile(tile: np.ndarray, y_offset: int) -> None:
-            tile_height, tile_width = tile.shape[:2]
-            results = bubble_seg_model.predict(
-                source=tile[:, :, ::-1],
-                conf=BUBSEG_CONF,
-                iou=YOLO_IOU,
-                verbose=False,
-                device=dev_target,
-                retina_masks=(task_type == "segment"),
-            )
-            for result in results:
-                if result.boxes is None:
-                    continue
-                if task_type == "segment" and result.masks is not None:
-                    for seg_mask in result.masks.data:
-                        seg_np = (seg_mask.cpu().numpy() > 0.5).astype(np.uint8) * 255
-                        seg_np = cv2.resize(seg_np, (tile_width, tile_height), interpolation=cv2.INTER_NEAREST)
-                        interior[y_offset:y_offset + tile_height, :] = cv2.bitwise_or(
-                            interior[y_offset:y_offset + tile_height, :],
-                            seg_np,
-                        )
-                else:
-                    for box in result.boxes.xyxy:
-                        x0, y0, x1, y1 = map(int, box.cpu().numpy())
-                        cv2.rectangle(interior, (x0, y_offset + y0), (x1, y_offset + y1), 255, -1)
-
-        if h / w < 2.0:
-            add_tile(image_bgr, 0)
-        else:
-            tile_h = min(h, max(1280, w * 2))
-            overlap = min(350, max(0, tile_h // 3))
-            stride = max(1, tile_h - overlap)
-            y_start = 0
-            while y_start < h:
-                y_end = min(y_start + tile_h, h)
-                if y_end == h and y_start > 0:
-                    y_start = max(0, h - tile_h)
-                    y_end = h
-                add_tile(image_bgr[y_start:y_end, :], y_start)
-                if y_end == h:
-                    break
-                y_start += stride
+        results = bubble_seg_model.predict(
+            source=image_bgr[:, :, ::-1],
+            conf=BUBSEG_CONF,
+            iou=YOLO_IOU,
+            verbose=False,
+            device=dev_target,
+            retina_masks=(task_type == "segment"),
+        )
+        for r in results:
+            if r.boxes is None:
+                continue
+            if task_type == "segment" and r.masks is not None:
+                for seg_mask in r.masks.data:
+                    seg_np = (seg_mask.cpu().numpy() > 0.5).astype(np.uint8) * 255
+                    seg_np = cv2.resize(seg_np, (w, h), interpolation=cv2.INTER_NEAREST)
+                    interior = cv2.bitwise_or(interior, seg_np)
+            else:
+                for box in r.boxes.xyxy:
+                    x0, y0, x1, y1 = map(int, box.cpu().numpy())
+                    cv2.rectangle(interior, (x0, y0), (x1, y1), 255, -1)
     except Exception as exc:
         log.warning("bubble_seg_model inference failed (non-fatal): %s", exc)
     return interior
@@ -1076,13 +876,13 @@ def _lama_inpaint_tile(img_rgb: np.ndarray, mask: np.ndarray, size: int = 512) -
     contours, _ = cv2.findContours(dilated_for_merge, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
     
     if not contours:
-        return img_out
+        return img_rgb
 
     input_names = [inp.name for inp in lama_session.get_inputs()]
 
     for cnt in contours:
         rx, ry, rw, rh = cv2.boundingRect(cnt)
-        pad = 6
+        pad = 8  # Reduced from 24 to protect square bubble borders
         x0 = max(0, rx - pad)
         y0 = max(0, ry - pad)
         x1 = min(w, rx + rw + pad)
@@ -1113,103 +913,16 @@ def _lama_inpaint_tile(img_rgb: np.ndarray, mask: np.ndarray, size: int = 512) -
         out_img_512 = np.clip(out[0].transpose(1, 2, 0) * 255.0, 0.0, 255.0).astype(np.uint8)
         out_img_orig = cv2.resize(out_img_512, (cw, ch), interpolation=cv2.INTER_CUBIC)
 
-        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-        dilated_mask = cv2.dilate(crop_mask, kernel, iterations=1)
-        blend_mask = cv2.GaussianBlur(dilated_mask, (5, 5), 0).astype(np.float32) / 255.0
-        blend_mask = np.expand_dims(blend_mask, axis=-1)
-
-        blended = (out_img_orig.astype(np.float32) * blend_mask + crop_img.astype(np.float32) * (1.0 - blend_mask))
-        img_out[y0:y1, x0:x1] = np.clip(blended, 0, 255).astype(np.uint8)
+        # FIX: Hard mask replacement - no alpha blending to prevent text ghosts.
+        # Only pixels where crop_mask==255 are replaced with LaMa output.
+        # Pixels outside the mask keep the original artwork 100% untouched.
+        hard_mask = (crop_mask > 127).astype(np.uint8)
+        hard_mask_3ch = np.stack([hard_mask, hard_mask, hard_mask], axis=-1)
+        result_crop = np.where(hard_mask_3ch, out_img_orig, crop_img)
+        img_out[y0:y1, x0:x1] = result_crop
 
     return img_out
 
-
-def _lama_inpaint_safe_regions(img_rgb: np.ndarray, mask: np.ndarray, size: int = LAMA_SIZE) -> np.ndarray:
-    """Inpaint independent protected regions without aspect-ratio distortion.
-
-    Unlike the legacy inpainting path, this never merges distant components and only
-    writes pixels selected by the protected mask.  It is reserved for gradients,
-    patterns, transparent bubbles, and system windows.
-    """
-    if lama_session is None or mask is None or mask.max() == 0:
-        return img_rgb
-
-    output = img_rgb.copy()
-    input_names = [inp.name for inp in lama_session.get_inputs()]
-    merge_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-    merged = cv2.dilate(mask, merge_kernel, iterations=1)
-    contours, _ = cv2.findContours(merged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    height, width = img_rgb.shape[:2]
-
-    for contour in contours:
-        x, y, region_width, region_height = cv2.boundingRect(contour)
-        padding = 32
-        x0, y0 = max(0, x - padding), max(0, y - padding)
-        x1, y1 = min(width, x + region_width + padding), min(height, y + region_height + padding)
-        crop = output[y0:y1, x0:x1]
-        crop_mask = mask[y0:y1, x0:x1]
-        if crop.size == 0 or crop_mask.max() == 0:
-            continue
-
-        crop_height, crop_width = crop.shape[:2]
-        side = max(crop_height, crop_width)
-        top = (side - crop_height) // 2
-        bottom = side - crop_height - top
-        left = (side - crop_width) // 2
-        right = side - crop_width - left
-        padded_crop = cv2.copyMakeBorder(crop, top, bottom, left, right, cv2.BORDER_REFLECT_101)
-        padded_mask = cv2.copyMakeBorder(crop_mask, top, bottom, left, right, cv2.BORDER_CONSTANT, value=0)
-
-        model_image = cv2.resize(padded_crop, (size, size), interpolation=cv2.INTER_CUBIC)
-        model_mask = cv2.resize(padded_mask, (size, size), interpolation=cv2.INTER_NEAREST)
-        model_output = lama_session.run(None, {
-            input_names[0]: model_image.transpose(2, 0, 1)[np.newaxis].astype(np.float32) / 255.0,
-            input_names[1]: (model_mask[np.newaxis, np.newaxis] > 127).astype(np.float32),
-        })[0]
-        restored = np.clip(model_output[0].transpose(1, 2, 0) * 255.0, 0.0, 255.0).astype(np.uint8)
-        restored = cv2.resize(restored, (side, side), interpolation=cv2.INTER_CUBIC)
-        restored = restored[top:top + crop_height, left:left + crop_width]
-
-        candidate = _blend_complex_result(crop, restored, crop_mask)
-        if _has_new_boundary_artifact(crop, candidate, crop_mask):
-            log.warning("Rejected complex inpainting result with a new boundary artifact.")
-            continue
-        output[y0:y1, x0:x1] = candidate
-
-    return output
-
-
-def _blend_complex_result(source: np.ndarray, restored: np.ndarray, mask: np.ndarray) -> np.ndarray:
-    """Feather only within a protected text mask, never across a bubble boundary."""
-    distance = cv2.distanceTransform(mask, cv2.DIST_L2, 3)
-    radius = max(1.0, COMPLEX_FEATHER_RADIUS)
-    alpha = np.clip((distance + 1.0) / radius, 0.0, 1.0)
-    alpha = np.expand_dims(alpha, axis=-1)
-    blended = source.astype(np.float32) * (1.0 - alpha) + restored.astype(np.float32) * alpha
-    result = source.copy()
-    result[mask > 0] = np.clip(blended, 0, 255).astype(np.uint8)[mask > 0]
-    return result
-
-
-def _has_new_boundary_artifact(source: np.ndarray, candidate: np.ndarray, mask: np.ndarray) -> bool:
-    """Reject a generated hard edge when the original boundary was locally smooth."""
-    inner = cv2.subtract(mask, cv2.erode(mask, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)), iterations=1))
-    if cv2.countNonZero(inner) < 12:
-        return False
-    source_gray = cv2.cvtColor(source, cv2.COLOR_RGB2GRAY)
-    candidate_gray = cv2.cvtColor(candidate, cv2.COLOR_RGB2GRAY)
-    source_edges = cv2.magnitude(
-        cv2.Sobel(source_gray, cv2.CV_32F, 1, 0, ksize=3),
-        cv2.Sobel(source_gray, cv2.CV_32F, 0, 1, ksize=3),
-    )
-    candidate_edges = cv2.magnitude(
-        cv2.Sobel(candidate_gray, cv2.CV_32F, 1, 0, ksize=3),
-        cv2.Sobel(candidate_gray, cv2.CV_32F, 0, 1, ksize=3),
-    )
-    source_mean = float(source_edges[inner > 0].mean())
-    candidate_mean = float(candidate_edges[inner > 0].mean())
-    return source_mean < 12.0 and candidate_mean > max(18.0, source_mean * 2.5)
-
 def _extract_precise_text_mask(img_rgb: np.ndarray, mask: np.ndarray, c_constant: int = C_CONSTANT) -> np.ndarray:
     """Refines YOLO text masks into pixel-perfect text stroke masks including drop-shadows & font halos.
     Protects character skin, eyes, and bubble outline borders.
@@ -1242,39 +955,42 @@ def _extract_precise_text_mask(img_rgb: np.ndarray, mask: np.ndarray, c_constant
 
         blurred = cv2.GaussianBlur(crop_gray, (3, 3), 0)
 
+        border_pixels = np.concatenate([
+            blurred[0, :],
+            blurred[-1, :],
+            blurred[:, 0],
+            blurred[:, -1]
+        ])
+        bg_brightness = np.median(border_pixels) if border_pixels.size > 0 else 255
+
         # Multi-scale adaptive thresholding + Otsu thresholding for thick/large fonts
         max_odd = min_dim - 1 if min_dim % 2 == 0 else min_dim
         block_size_small = min(25, max_odd)
         block_size_large = min(101, max_odd)
-        dark_s = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, block_size_small, c_constant)
-        dark_l = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, block_size_large, c_constant)
-        _, dark_o = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
-        light_s = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, block_size_small, c_constant)
-        light_l = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, block_size_large, c_constant)
-        _, light_o = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-
-        dark_text = cv2.bitwise_or(cv2.bitwise_or(dark_s, dark_l), dark_o)
-        light_text = cv2.bitwise_or(cv2.bitwise_or(light_s, light_l), light_o)
+
+        if bg_brightness > 127:
+            thresh_s = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, block_size_small, c_constant)
+            thresh_l = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, block_size_large, c_constant)
+            _, thresh_o = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+        else:
+            thresh_s = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, block_size_small, c_constant)
+            thresh_l = cv2.adaptiveThreshold(blurred, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, block_size_large, c_constant)
+            _, thresh_o = cv2.threshold(blurred, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+
+        # Union of threshold passes
+        thresh = cv2.bitwise_or(thresh_s, thresh_l)
+        thresh = cv2.bitwise_or(thresh, thresh_o)
+
+        # Morphological closing to seal hollow centers of thick fonts
         close_k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
-        dark_text = cv2.morphologyEx(dark_text, cv2.MORPH_CLOSE, close_k)
-        light_text = cv2.morphologyEx(light_text, cv2.MORPH_CLOSE, close_k)
+        thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, close_k)
 
         guide_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11, 11))
         spatial_guide = cv2.dilate(crop_mask, guide_kernel, iterations=3)
-        candidates = [
-            cv2.bitwise_and(dark_text, spatial_guide),
-            cv2.bitwise_and(light_text, spatial_guide),
-        ]
-        guide_area = max(1, cv2.countNonZero(spatial_guide))
-        candidate_densities = [cv2.countNonZero(candidate) / guide_area for candidate in candidates]
-        valid_candidates = [
-            (density, candidate)
-            for density, candidate in zip(candidate_densities, candidates)
-            if 0.003 <= density <= 0.65
-        ]
-        if not valid_candidates:
-            continue
-        stroke_mask = min(valid_candidates, key=lambda item: item[0])[1]
+        stroke_mask = cv2.bitwise_and(thresh, spatial_guide)
+
+        # Union with raw YOLO segment mask to guarantee font drop-shadows & light font halos are NEVER omitted
+        stroke_mask = cv2.bitwise_or(stroke_mask, crop_mask)
 
         # Connected-component filtering: keep valid text components, remove noise dots < MIN_COMP_AREA
         num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(stroke_mask, connectivity=8)
@@ -1305,7 +1021,7 @@ def _cpu_fallback_cleaner(img_bgr: np.ndarray) -> np.ndarray:
 def clean_single_image_helper(
     image_bytes: bytes,
     dilate_iter: int = DILATE_ITER,
-    remove_sfx: bool = False,
+    remove_sfx: bool = True,
     c_constant: int = C_CONSTANT,
 ) -> bytes:
     """Processes and cleans a single manga/manhwa page image.
@@ -1320,18 +1036,14 @@ def clean_single_image_helper(
 
         img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
 
-        masks = _prepare_cleaning_masks(img_bgr, img_rgb, dilate_iter, remove_sfx, c_constant)
-        if masks["coarse"].max() > 0:
-            img_clean = img_rgb.copy()
-            if masks["legacy"].max() > 0:
-                img_clean = _hybrid_inpaint(img_clean, masks["legacy"])
-            if masks["complex"].max() > 0:
-                img_clean = _lama_inpaint_safe_regions(img_clean, masks["complex"])
-            if masks["excluded"].max() > 0:
-                log.info(
-                    "Protected %d text-mask pixels near bubble borders or without a safe interior.",
-                    cv2.countNonZero(masks["excluded"]),
-                )
+        # Pass 1: Build primary text mask
+        coarse_mask = _build_text_mask(img_bgr, dilate_iter=dilate_iter, remove_sfx=remove_sfx)
+
+        if coarse_mask.max() > 0:
+            dilated_coarse = cv2.dilate(coarse_mask, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5)), iterations=1)
+            precise_mask = _extract_precise_text_mask(img_rgb, coarse_mask, c_constant=c_constant)
+            final_mask = cv2.bitwise_or(precise_mask, dilated_coarse)
+            img_clean = _hybrid_inpaint(img_rgb, final_mask)
         else:
             img_clean = img_rgb.copy()
 
@@ -1349,22 +1061,6 @@ def clean_single_image_helper(
         return image_bytes
 
 
-def cleaning_diagnostics(image_bytes: bytes, dilate_iter: int = DILATE_ITER, remove_sfx: bool = False) -> dict[str, bytes]:
-    """Return PNG masks that explain which pixels the cleaner will modify or protect."""
-    ensure_models_loaded()
-    img_bgr = cv2.imdecode(np.frombuffer(image_bytes, np.uint8), cv2.IMREAD_COLOR)
-    if img_bgr is None:
-        raise ValueError("Cannot decode image")
-    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
-    masks = _prepare_cleaning_masks(img_bgr, img_rgb, dilate_iter, remove_sfx, C_CONSTANT)
-    result = {}
-    for name, mask in masks.items():
-        ok, encoded = cv2.imencode(".png", mask)
-        if ok:
-            result[f"{name}_mask.png"] = encoded.tobytes()
-    return result
-
-
 import concurrent.futures
 
 paddle_ocr_readers: dict = {}
@@ -1474,10 +1170,12 @@ def clean_single_image(image_bytes: bytes, dilate_iter: int = 3, remove_sfx: boo
     return clean_single_image_helper(image_bytes, dilate_iter=dilate_iter, remove_sfx=remove_sfx)
 
 
+# ──────────────────────────────────────────────
 # ────────────────────────────────────────────────────────────────────────────
 # Gradio UI Setup
 # ────────────────────────────────────────────────────────────────────────────
 
+@spaces.GPU(duration=120)
 def process_gradio_zip(file_obj, key: str, dilate_iter: int = 3, remove_sfx: bool = False) -> tuple[Optional[str], str]:
     if API_KEY and key:
         if not secrets.compare_digest(key, API_KEY):
@@ -1653,32 +1351,6 @@ def patched_create_app(cls, blocks, *args, **kwargs):
             },
         )
 
-    @app.post("/clean_diagnostics")
-    async def clean_diagnostics(
-        file: UploadFile = File(..., description="Single manga image to inspect"),
-        dilate_iter: int = DILATE_ITER,
-        remove_sfx: bool = False,
-        _key: str = Depends(verify_key_dep),
-    ):
-        content = await file.read()
-        if len(content) > MAX_ZIP_MB * 1024 * 1024:
-            raise HTTPException(status_code=413, detail=f"Image too large (max {MAX_ZIP_MB} MB)")
-        try:
-            masks = cleaning_diagnostics(content, dilate_iter=dilate_iter, remove_sfx=remove_sfx)
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-
-        out_buf = io.BytesIO()
-        with zipfile.ZipFile(out_buf, "w", compression=zipfile.ZIP_DEFLATED) as out_zip:
-            for name, data in masks.items():
-                out_zip.writestr(name, data)
-        out_buf.seek(0)
-        return Response(
-            content=out_buf.read(),
-            media_type="application/zip",
-            headers={"Content-Disposition": "attachment; filename=cleaning_diagnostics.zip"},
-        )
-
     @app.post("/process_ocr_zip")
     async def process_ocr_zip(
         file: UploadFile = File(..., description="ZIP file containing manga images"),